package edu.server.servicio;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

import edu.client.ProduccionService.ProduccionService;
import edu.server.dominio.Administrador;
import edu.server.dominio.Almacen;
import edu.server.dominio.D_Inventario;
import edu.server.dominio.D_OrdenFabricacionGeneral;
import edu.server.dominio.D_Producto;
import edu.server.dominio.Estado;
import edu.server.dominio.Insumos;
import edu.server.dominio.Produccion;
import edu.server.repositorio.DetalleRequerimientoMateriales;
import edu.server.repositorio.Empleado;
import edu.server.repositorio.EstadoOrden;
import edu.server.repositorio.Insumo;
import edu.server.repositorio.Inventario;
import edu.server.repositorio.MedidasVariablesEstandar;
import edu.server.repositorio.OrdenProvisionInsumo;
import edu.server.repositorio.ProveedorDeInsumo;
import edu.server.repositorio.RemitoInternoInsumo;
import edu.server.repositorio.RenglonOrdenProvisionInsumo;
import edu.server.repositorio.RenglonOrdenProvisionInsumoId;
import edu.server.repositorio.RenglonRemitoInternoInsumo;
import edu.server.repositorio.RenglonRemitoInternoInsumoId;
import edu.server.repositorio.RequerimientoCompra;
import edu.server.repositorio.RequerimientoMateriales;
import edu.server.repositorio.ReservaProducto;
import edu.shared.DTO.ClaseProductoDTO;
import edu.shared.DTO.DetalleRequerimientoMaterialesDTO;
import edu.shared.DTO.ElementoProductoDTO;
import edu.shared.DTO.EmpleadoDTO;
import edu.shared.DTO.InsumoDTO;
import edu.shared.DTO.InventarioDTO;
import edu.shared.DTO.ListaDeMaterialesDTO;
import edu.shared.DTO.MaterialProductoDTO;
import edu.shared.DTO.MedidaFijaProductoDTO;
import edu.shared.DTO.MedidaVariableEstandarDTO;
import edu.shared.DTO.OrdenFabricacionGeneralDTO;
import edu.shared.DTO.OrdenProvisionInsumoDTO;
import edu.shared.DTO.ProductoDTO;
import edu.shared.DTO.ProveedorDeInsumosDTO;
import edu.shared.DTO.RemitoProvisionInsumoDTO;
import edu.shared.DTO.RenglonListaMaterialesDTO;
import edu.shared.DTO.RenglonOrdenFabricacionGeneralDTO;
import edu.shared.DTO.RenglonOrdenProvisionInsumoDTO;
import edu.shared.DTO.RenglonRemitoProvisionInsumoDTO;
import edu.shared.DTO.RequerimientoCompraDTO;
import edu.shared.DTO.RequerimientoMaterialDTO;
import edu.shared.DTO.ReservaProductoDTO;
import edu.shared.DTO.UsuarioCompDTO;

public class ProduccionServiceImpl extends RemoteServiceServlet implements ProduccionService{

	/**
	 * 
	 */
	private static final long serialVersionUID = 5391111874855282111L;

	@Override
	public List<String> getNombresInsumos(String letra) throws IllegalArgumentException {
		
		Insumos adminInsumo = new Insumos();
		
		return adminInsumo.getNombresInsumos(letra);
		
	}
	
	@Override
	public List<String> getNombresMarcas() throws IllegalArgumentException {
		
		Insumos adminInsumo = new Insumos();
		
		return adminInsumo.getNombresMarcas();
		
	}
	
	@Override
	public List<String> getNombresMarcasSegunInsumo(String nombreInsumo) throws IllegalArgumentException {
		
		Insumos adminInsumos = new Insumos();
		
		return adminInsumos.getNombresMarcasSegunInsumo(nombreInsumo);
	}
	
	@Override
	public EmpleadoDTO getEmpleado(String nombre, String apellido, String rol) throws IllegalArgumentException {
		
		edu.server.dominio.D_Empleado adminEmpleado = new edu.server.dominio.D_Empleado(); 
		Empleado emp;
		EmpleadoDTO empleadoDTO = new EmpleadoDTO();
		
		int idEmpleado = adminEmpleado.getIdEmpleado(nombre, apellido, rol);
		
		emp = adminEmpleado.getEmpleado(idEmpleado);
		
		empleadoDTO.setApellido(emp.getApellido());
		empleadoDTO.setNombre(emp.getNombre());
		empleadoDTO.setIdEmpleado(emp.getIdEmpleado());
		
		for (Empleado emple : emp.getEmpleadosForEmpleado()) {
		
			EmpleadoDTO aux = new EmpleadoDTO();
			aux.setIdEmpleado(emple.getIdEmpleado());
			aux.setApellido(emple.getApellido());
			aux.setNombre(emple.getNombre());
			
			
			empleadoDTO.getListaEmpACargo().add(aux);
			
			
		}

		return empleadoDTO;
	}
	

	
//	@Override
//	public boolean registrarOrdenProvisionInsumo(OrdenProvisionInsumoDTO orden) throws IllegalArgumentException {
//		Insumos adminInsumos = new Insumos();
//		Produccion adminProduccion = new Produccion();
//		EstadoOrden estado = new EstadoOrden();
//		Estado adminEstado = new Estado();
//		int idEstado = adminEstado.getIdEstado("GENERADA");
//		estado.setIdEstadoOrden(idEstado);
//		estado.setNombre("GENERADA");
//		Empleado registradoPor = new Empleado();
//		registradoPor.setIdEmpleado(orden.getEmpleadoByIdPedidoPor().getIdEmpleado());
//		Empleado registradoPara = new Empleado();
//		registradoPara.setIdEmpleado(orden.getEmpleadoByIdPedidoPara().getIdEmpleado());
//		
//		OrdenProvisionInsumo nuevaOrden = new OrdenProvisionInsumo();
//		nuevaOrden.setEmpleadoByIdPedidoPara(registradoPara);
//		nuevaOrden.setEmpleadoByIdPedidoPor(registradoPor);
//		nuevaOrden.setEstadoOrden(estado);
//		nuevaOrden.setFechaEdicion(orden.getFechaEdicion());
//		nuevaOrden.setFechaGeneracion(orden.getFechaGeneracion());
//		nuevaOrden.setObservaciones(orden.getObservaciones());
//		
//		for (RenglonOrdenProvisionInsumoDTO renglon : orden.getRenglonOrdenProvisionInsumos()) {
//			 RenglonOrdenProvisionInsumo nuevoRenglon = new RenglonOrdenProvisionInsumo();
//			 RenglonOrdenProvisionInsumoId id = new RenglonOrdenProvisionInsumoId();
//			 id.setIdRenglon(renglon.getIdRenglon());
//			 Insumo insumo = new Insumo();
//			 int idInsumo = adminInsumos.getIdInsumo(renglon.getInsumo().getNombre(), renglon.getInsumo().getMarca());
//			 insumo.setIdInsumo(idInsumo);
//			 nuevoRenglon.setCantidadRequerida(renglon.getCantidadRequerida());
//			 nuevoRenglon.setInsumo(insumo);
//			 nuevoRenglon.setId(id);
//		
//			 nuevaOrden.getRenglonOrdenProvisionInsumos().add(nuevoRenglon);
//		}
//		
//		return adminProduccion.registrarOrdenProvisionInsumo(nuevaOrden);
//		
//	}
	
	@Override
	public Long registrarOrdenProvisionInsumo(OrdenProvisionInsumoDTO orden) throws IllegalArgumentException {
		
		Insumos adminInsumos = new Insumos();
		Produccion adminProduccion = new Produccion();
		EstadoOrden estado = new EstadoOrden();
		Estado adminEstado = new Estado();
		int idEstado = adminEstado.getIdEstado("GENERADA");
		estado.setIdEstadoOrden(idEstado);
		estado.setNombre("GENERADA");
		Empleado registradoPor = new Empleado();
		registradoPor.setIdEmpleado(orden.getEmpleadoByIdPedidoPor().getIdEmpleado());
		Empleado registradoPara = new Empleado();
		registradoPara.setIdEmpleado(orden.getEmpleadoByIdPedidoPara().getIdEmpleado());
		
		OrdenProvisionInsumo nuevaOrden = new OrdenProvisionInsumo();
		nuevaOrden.setEmpleadoByIdPedidoPara(registradoPara);
		nuevaOrden.setEmpleadoByIdPedidoPor(registradoPor);
		nuevaOrden.setEstadoOrden(estado);
		nuevaOrden.setFechaEdicion(orden.getFechaEdicion());
		nuevaOrden.setFechaGeneracion(orden.getFechaGeneracion());
		nuevaOrden.setObservaciones(orden.getObservaciones());
		
		for (RenglonOrdenProvisionInsumoDTO renglon : orden.getRenglonOrdenProvisionInsumos()) {
			 RenglonOrdenProvisionInsumo nuevoRenglon = new RenglonOrdenProvisionInsumo();
			 RenglonOrdenProvisionInsumoId id = new RenglonOrdenProvisionInsumoId();
			 id.setIdRenglon(renglon.getIdRenglon());
			 Insumo insumo = new Insumo();
			 int idInsumo = adminInsumos.getIdInsumo(renglon.getInsumo().getNombre(), renglon.getInsumo().getMarca());
			 insumo.setIdInsumo(idInsumo);
			 nuevoRenglon.setCantidadRequerida(renglon.getCantidadRequerida());
			 nuevoRenglon.setInsumo(insumo);
			 nuevoRenglon.setId(id);
		
			 nuevaOrden.getRenglonOrdenProvisionInsumos().add(nuevoRenglon);
		}
		
		long result = adminProduccion.registrarOrdenProvisionInsumo(nuevaOrden,"");
		return result;
		
	}
	
//	@Override
//	public boolean registrarOrdenProvisionInsumoGerente(OrdenProvisionInsumoDTO orden) throws IllegalArgumentException {
//		Insumos adminInsumos = new Insumos();
//		Produccion adminProduccion = new Produccion();
//		EstadoOrden estado = new EstadoOrden();
//		Estado adminEstado = new Estado();
//		int idEstado = adminEstado.getIdEstado("VALIDADA");
//		estado.setIdEstadoOrden(idEstado);
//		estado.setNombre("VALIDADA");
//		Empleado registradoPor = new Empleado();
//		registradoPor.setIdEmpleado(orden.getEmpleadoByIdPedidoPor().getIdEmpleado());
//		Empleado registradoPara = new Empleado();
//		registradoPara.setIdEmpleado(orden.getEmpleadoByIdPedidoPara().getIdEmpleado());
//		
//		OrdenProvisionInsumo nuevaOrden = new OrdenProvisionInsumo();
//		nuevaOrden.setEmpleadoByIdPedidoPara(registradoPara);
//		nuevaOrden.setEmpleadoByIdPedidoPor(registradoPor);
//		nuevaOrden.setEstadoOrden(estado);
//		nuevaOrden.setFechaEdicion(orden.getFechaEdicion());
//		nuevaOrden.setFechaGeneracion(orden.getFechaGeneracion());
//		nuevaOrden.setObservaciones(orden.getObservaciones());
//		
//		for (RenglonOrdenProvisionInsumoDTO renglon : orden.getRenglonOrdenProvisionInsumos()) {
//			 RenglonOrdenProvisionInsumo nuevoRenglon = new RenglonOrdenProvisionInsumo();
//			 RenglonOrdenProvisionInsumoId id = new RenglonOrdenProvisionInsumoId();
//			 id.setIdRenglon(renglon.getIdRenglon());
//			 Insumo insumo = new Insumo();
//			 int idInsumo = adminInsumos.getIdInsumo(renglon.getInsumo().getNombre(), renglon.getInsumo().getMarca());
//			 insumo.setIdInsumo(idInsumo);
//			 nuevoRenglon.setCantidadRequerida(renglon.getCantidadRequerida());
//			 nuevoRenglon.setInsumo(insumo);
//			 nuevoRenglon.setId(id);
//		
//			 nuevaOrden.getRenglonOrdenProvisionInsumos().add(nuevoRenglon);
//		}
//		
//		return adminProduccion.registrarOrdenProvisionInsumo(nuevaOrden);
//		
//	}
	
	@Override
	public Long registrarOrdenProvisionInsumoGerente(OrdenProvisionInsumoDTO orden) throws IllegalArgumentException {
		
		Insumos adminInsumos = new Insumos();
		Produccion adminProduccion = new Produccion();
		EstadoOrden estado = new EstadoOrden();
		Estado adminEstado = new Estado();
		int idEstado = adminEstado.getIdEstado("VALIDADA");
		estado.setIdEstadoOrden(idEstado);
		estado.setNombre("VALIDADA");
		Empleado registradoPor = new Empleado();
		registradoPor.setIdEmpleado(orden.getEmpleadoByIdPedidoPor().getIdEmpleado());
		Empleado registradoPara = new Empleado();
		registradoPara.setIdEmpleado(orden.getEmpleadoByIdPedidoPara().getIdEmpleado());
		
		OrdenProvisionInsumo nuevaOrden = new OrdenProvisionInsumo();
		nuevaOrden.setEmpleadoByIdPedidoPara(registradoPara);
		nuevaOrden.setEmpleadoByIdPedidoPor(registradoPor);
		nuevaOrden.setEstadoOrden(estado);
		nuevaOrden.setFechaEdicion(orden.getFechaEdicion());
		nuevaOrden.setFechaGeneracion(orden.getFechaGeneracion());
		nuevaOrden.setObservaciones(orden.getObservaciones());
		
		for (RenglonOrdenProvisionInsumoDTO renglon : orden.getRenglonOrdenProvisionInsumos()) {
			 RenglonOrdenProvisionInsumo nuevoRenglon = new RenglonOrdenProvisionInsumo();
			 RenglonOrdenProvisionInsumoId id = new RenglonOrdenProvisionInsumoId();
			 id.setIdRenglon(renglon.getIdRenglon());
			 Insumo insumo = new Insumo();
			 int idInsumo = adminInsumos.getIdInsumo(renglon.getInsumo().getNombre(), renglon.getInsumo().getMarca());
			 insumo.setIdInsumo(idInsumo);
			 nuevoRenglon.setCantidadRequerida(renglon.getCantidadRequerida());
			 nuevoRenglon.setInsumo(insumo);
			 nuevoRenglon.setId(id);
		
			 nuevaOrden.getRenglonOrdenProvisionInsumos().add(nuevoRenglon);
		}
		
		long result = adminProduccion.registrarOrdenProvisionInsumo(nuevaOrden,"");
		return result;
		
	}
	
	@Override
	public List<String> getNombreEstados()throws IllegalArgumentException{
		
		Estado adminE = new Estado();
		return adminE.getNombreEstados();
		
	}
	
	@Override
	public List<OrdenProvisionInsumoDTO> getOrdenProvisionInsumo(String estado, int empleadoPor, int empleadoPara, String fecDesde, String fecHasta) throws IllegalArgumentException{
		
		Administrador adminAdmin = new Administrador();
		Estado adminEstados = new Estado();
		int idEstado = adminEstados.getIdEstado(estado);
		Produccion adminProd = new Produccion();
		
		List<OrdenProvisionInsumoDTO> listaResult = new LinkedList<OrdenProvisionInsumoDTO>();
		List<OrdenProvisionInsumo> result = new LinkedList<OrdenProvisionInsumo>();
		
		result = adminProd.getOrdenProvisionInsumo(idEstado, empleadoPor, empleadoPara, fecDesde, fecHasta);
		
		for (OrdenProvisionInsumo orden : result) {
			
			OrdenProvisionInsumoDTO ordendto = new OrdenProvisionInsumoDTO();
			ordendto.setIdOrdenProvisionInsumo(orden.getIdOrdenProvisionInsumo());
			ordendto.setEstadoOrden(adminEstados.getNombreEstado(orden.getEstadoOrden().getIdEstadoOrden()));
			ordendto.setFechaGeneracion(orden.getFechaGeneracion());
			EmpleadoDTO empPor = new EmpleadoDTO();
			empPor.setNombre(adminAdmin.getNombreEmpleado(orden.getEmpleadoByIdPedidoPor().getIdEmpleado()));
			EmpleadoDTO empPara = new EmpleadoDTO();
			empPara.setNombre(adminAdmin.getNombreEmpleado(orden.getEmpleadoByIdPedidoPara().getIdEmpleado()));		
			
			ordendto.setEmpleadoByIdPedidoPor(empPor);
			ordendto.setEmpleadoByIdPedidoPara(empPara);
			
			listaResult.add(ordendto);
			
		}
		
		return listaResult;
		
	}
	
	@Override
	public List<OrdenProvisionInsumoDTO> getOrdenProvisionInsumo(String estado, int empleadoPor, int empleadoPara, String fecDesde, String fecHasta, String nombreEmp, String apellidoEmp, String rolUsu) throws IllegalArgumentException{
		
		Administrador adminAdmin = new Administrador();
		Estado adminEstados = new Estado();
		int idEstado = adminEstados.getIdEstado(estado);
		Produccion adminProd = new Produccion();
		
		if(empleadoPor == 0 && rolUsu.compareTo("JEFE DE FABRICA")==0){
			
			List<Integer> listaId = new LinkedList<Integer>();
			
			EmpleadoDTO emp = new EmpleadoDTO();
			emp = this.getEmpleado(nombreEmp, apellidoEmp, rolUsu);
			
			listaId.add(emp.getIdEmpleado());
			
			//obtener los supervisores de un jefe de fabrica
			
			List<UsuarioCompDTO> listaSupervisores = new LinkedList<UsuarioCompDTO>();
			listaSupervisores = this.getUsuariosSupervisoresDeUnJefeDeFabrica(nombreEmp, apellidoEmp);

			for(UsuarioCompDTO usu : listaSupervisores){
			
				if(usu.getRolUsu().compareTo("SUPERVISOR")==0){

					EmpleadoDTO agregar = new EmpleadoDTO();
					agregar = this.getEmpleado(usu.getNombreEmp(), usu.getApellidoEmp(), "SUPERVISOR");
					
					listaId.add(agregar.getIdEmpleado());				
				}	
			}
			
			List<OrdenProvisionInsumoDTO> listaResult = new LinkedList<OrdenProvisionInsumoDTO>();
			List<OrdenProvisionInsumo> result = new LinkedList<OrdenProvisionInsumo>();
			
			for(Integer id : listaId){
				
				result.clear();
				
				result = adminProd.getOrdenProvisionInsumo(idEstado, id, empleadoPara, fecDesde, fecHasta);
				
				for (OrdenProvisionInsumo orden : result) {
					
					OrdenProvisionInsumoDTO ordendto = new OrdenProvisionInsumoDTO();
					ordendto.setIdOrdenProvisionInsumo(orden.getIdOrdenProvisionInsumo());
					ordendto.setEstadoOrden(adminEstados.getNombreEstado(orden.getEstadoOrden().getIdEstadoOrden()));
					ordendto.setFechaGeneracion(orden.getFechaGeneracion());
					EmpleadoDTO empPor = new EmpleadoDTO();
					empPor.setNombre(adminAdmin.getNombreEmpleado(orden.getEmpleadoByIdPedidoPor().getIdEmpleado()));
					EmpleadoDTO empPara = new EmpleadoDTO();
					empPara.setNombre(adminAdmin.getNombreEmpleado(orden.getEmpleadoByIdPedidoPara().getIdEmpleado()));		
					
					ordendto.setEmpleadoByIdPedidoPor(empPor);
					ordendto.setEmpleadoByIdPedidoPara(empPara);
					
					listaResult.add(ordendto);		
				}
				
			}
			
			return listaResult;
			
			
			
			
			

		
		}
		else{
			
			List<OrdenProvisionInsumoDTO> listaResult = new LinkedList<OrdenProvisionInsumoDTO>();
			List<OrdenProvisionInsumo> result = new LinkedList<OrdenProvisionInsumo>();
			
			result = adminProd.getOrdenProvisionInsumo(idEstado, empleadoPor, empleadoPara, fecDesde, fecHasta);
			
			for (OrdenProvisionInsumo orden : result) {
				
				OrdenProvisionInsumoDTO ordendto = new OrdenProvisionInsumoDTO();
				ordendto.setIdOrdenProvisionInsumo(orden.getIdOrdenProvisionInsumo());
				ordendto.setEstadoOrden(adminEstados.getNombreEstado(orden.getEstadoOrden().getIdEstadoOrden()));
				ordendto.setFechaGeneracion(orden.getFechaGeneracion());
				EmpleadoDTO empPor = new EmpleadoDTO();
				empPor.setNombre(adminAdmin.getNombreEmpleado(orden.getEmpleadoByIdPedidoPor().getIdEmpleado()));
				EmpleadoDTO empPara = new EmpleadoDTO();
				empPara.setNombre(adminAdmin.getNombreEmpleado(orden.getEmpleadoByIdPedidoPara().getIdEmpleado()));		
				
				ordendto.setEmpleadoByIdPedidoPor(empPor);
				ordendto.setEmpleadoByIdPedidoPara(empPara);
				
				listaResult.add(ordendto);		
			}
			
			return listaResult;
		}
		
		
		

		
		
		
	}
	
	@Override
	public List<OrdenProvisionInsumoDTO> getOrdenProvisionInsumoCompletos(String estado, int empleadoPor, int empleadoPara, String fecDesde, String fecHasta) throws IllegalArgumentException{
		
		Estado adminEstados = new Estado();
		int idEstado = adminEstados.getIdEstado(estado);
		Produccion adminProd = new Produccion();
		
		List<OrdenProvisionInsumoDTO> listaResult = new LinkedList<OrdenProvisionInsumoDTO>();
		List<OrdenProvisionInsumo> result = new LinkedList<OrdenProvisionInsumo>();
		
		result = adminProd.getOrdenProvisionInsumo(idEstado, empleadoPor, empleadoPara, fecDesde, fecHasta);
		
		for (OrdenProvisionInsumo orden : result) {
			
			OrdenProvisionInsumoDTO ordendto = new OrdenProvisionInsumoDTO();
			ordendto = this.getOrdenProvisionInsumoSegunId(orden.getIdOrdenProvisionInsumo());
			
			listaResult.add(ordendto);
			
		}
		
		return listaResult;		
	}
	
	@SuppressWarnings("rawtypes")
	@Override
	public OrdenProvisionInsumoDTO getOrdenProvisionInsumoSegunId(long idOrden) throws IllegalArgumentException{
		
		OrdenProvisionInsumoDTO orden = new OrdenProvisionInsumoDTO();
		OrdenProvisionInsumo ordenComun = new OrdenProvisionInsumo();
		Estado adminEstados = new Estado();
		Administrador adminAdmin = new Administrador();
		Produccion adminProd = new Produccion();
		
		ordenComun = adminProd.getOrdenProvisionInsumoSegunId(idOrden);
		orden.setIdOrdenProvisionInsumo(idOrden);
		String estado = adminEstados.getNombreEstado(ordenComun.getEstadoOrden().getIdEstadoOrden());
		orden.setEstadoOrden(estado);
		orden.setFechaGeneracion(ordenComun.getFechaGeneracion());
		
		if(ordenComun.getFechaCierre()!=null)
			orden.setFechaCierre(ordenComun.getFechaCierre());
		
		orden.setObservaciones(ordenComun.getObservaciones());
		
		EmpleadoDTO empPor = new EmpleadoDTO();
		EmpleadoDTO empPara = new EmpleadoDTO();
		Empleado empPorComun = adminAdmin.getEmpleado(ordenComun.getEmpleadoByIdPedidoPor().getIdEmpleado());
		Empleado empParaComun = adminAdmin.getEmpleado(ordenComun.getEmpleadoByIdPedidoPara().getIdEmpleado());
		empPor.setNombre(empPorComun.getNombre());
		empPor.setApellido(empPorComun.getApellido());
		empPara.setNombre(empParaComun.getNombre());
		empPara.setApellido(empParaComun.getApellido());
		
		orden.setEmpleadoByIdPedidoPor(empPor);
		orden.setEmpleadoByIdPedidoPara(empPara);
		
				
		Iterator renglones = ordenComun.getRenglonOrdenProvisionInsumos().iterator();
		
		while (renglones.hasNext()){
					
			RenglonOrdenProvisionInsumoDTO renglonNuevo = new RenglonOrdenProvisionInsumoDTO();
			RenglonOrdenProvisionInsumo renglon = (RenglonOrdenProvisionInsumo) renglones.next();
			
			int idRenglon = ((RenglonOrdenProvisionInsumoId)renglon.getId()).getIdRenglon();
			
			renglonNuevo.setIdRenglon(idRenglon);
			
			InsumoDTO insumoNuevo = new InsumoDTO();
			insumoNuevo = this.getInsumoCompleto(renglon.getInsumo().getIdInsumo(), "");
			
			renglonNuevo.setInsumo(insumoNuevo);
			
			renglonNuevo.setCantidadRequerida(renglon.getCantidadRequerida());
			
			orden.getRenglonOrdenProvisionInsumos().add(renglonNuevo);
						

		}
				
		
		
		
		return orden;
	}
		
	public InsumoDTO getInsumoCompleto(int idInsumo, String nombreInsumo)  throws IllegalArgumentException {
		
		InsumoDTO result = new InsumoDTO();
		Insumo insumo = new Insumo();
		Insumos adminInsumos = new Insumos();
		
		insumo = adminInsumos.getInsumoCompleto(idInsumo, nombreInsumo);
		
		result.setIdInsumo(insumo.getIdInsumo());
		result.setNombre(insumo.getNombre());
		result.setLoteCompra(insumo.getLoteCompra());
		result.setStockSeguridad(insumo.getStockSeguridad());
		result.setObservaciones(insumo.getObservaciones());
		if(insumo.getCantidad() != -1 && insumo.getCantidad() != 0){
			result.setCantidad(insumo.getCantidad());
		}
		else{
			result.setCantidad(0);
		}
		result.setMarca(insumo.getMarca().getNombre());
		result.setCategoria(insumo.getCategoria().getNombre());
		

			for (ProveedorDeInsumo prov : insumo.getProveedorDeInsumos()) {
				
				ProveedorDeInsumosDTO proveedor = new ProveedorDeInsumosDTO();
				
				if(prov.getPrecio() == null)
					proveedor.setPrecio();
				else{
					Double precio = Double.parseDouble(prov.getPrecio().toString());
					proveedor.setPrecio(precio);
				}
				
				proveedor.setNombre(prov.getProveedor().getNombre());
				proveedor.setObservaciones(prov.getObservaciones());
				
				result.getProveedor().add(proveedor);
				
			}
			
		
			
		return result;
	}

	@Override
	public double getCantFaltanteInsumo(InsumoDTO insumo, long idOrdenProvisionInsumo) throws IllegalArgumentException{
		
		Almacen adminAlmacen = new Almacen();
		double cantidadFaltante = 0;
		double cantidadIngresada = 0;
		Estado adminEstados = new Estado();
		int idEstado = adminEstados.getIdEstado("CANCELADA");
		
		List<RemitoInternoInsumo> listaRemitos = adminAlmacen.getRemitosInternosEnEstadoDistintoACancelada(idOrdenProvisionInsumo, idEstado);				
		OrdenProvisionInsumoDTO orden = this.getOrdenProvisionInsumoSegunId(idOrdenProvisionInsumo);
				
		for (RenglonOrdenProvisionInsumoDTO renglon : orden.getRenglonOrdenProvisionInsumos()) {
			if(renglon.getInsumo().getIdInsumo() == insumo.getIdInsumo()){
				cantidadFaltante = renglon.getCantidadRequerida();
			}
		}	
		
		if(!listaRemitos.isEmpty()){
			for(RemitoInternoInsumo remito : listaRemitos){
				for(RenglonRemitoInternoInsumo renglon : remito.getRenglonRemitoInternoInsumos()){
					if(renglon.getInsumo().getIdInsumo() == insumo.getIdInsumo())
						cantidadIngresada+= renglon.getCantidadEntregada();
				}
			}
		}
		
		cantidadFaltante = cantidadFaltante - cantidadIngresada;
		return cantidadFaltante;
	}
			
	//------------------------------------------------------------------------------------------------------------------------
	//-------- En este metodo no debe usarse esta mal ------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------------
	
	@SuppressWarnings("rawtypes")
	@Override
	public Long registrarRemitoProvisionInsumo(RemitoProvisionInsumoDTO remito) throws IllegalArgumentException{
		
		Almacen adminAlmacen = new Almacen();
		edu.server.dominio.D_Empleado adminEmpleado = new edu.server.dominio.D_Empleado();
		Estado adminEstado = new Estado();
		Produccion adminProd = new Produccion();
		Insumos adminInsumo = new Insumos();
		Insumo insumo = new Insumo();
		
		int idEstado = adminEstado.getIdEstado(remito.getEstadoOrden());
		EstadoOrden est = adminEstado.getEstadoCompleto(idEstado);
		
		int idEmpleado = adminEmpleado.getIdEmpleado(remito.getEmpleado());
		Empleado emp = adminEmpleado.getEmpleado(idEmpleado);
		
		OrdenProvisionInsumo opi = new OrdenProvisionInsumo();
		opi = adminProd.getOrdenProvisionInsumoSegunId(remito.getIdOrdenProvisionInsumo());
		
		RemitoInternoInsumo remitoGuardar = new RemitoInternoInsumo();
		remitoGuardar.setEmpleado(emp);
		remitoGuardar.setEstadoOrden(est);
		remitoGuardar.setFechaCierre(remito.getFechaCierre());
		remitoGuardar.setFechaEdicion(remito.getFechaEdicion());
		remitoGuardar.setFechaGenaracion(remito.getFechaGenaracion());
		remitoGuardar.setObservaciones(remito.getObservaciones());
		remitoGuardar.setOrdenProvisionInsumo(opi);
		
		long idRemito = adminAlmacen.registrarRemitoProvisionInsumo(remitoGuardar); 
				
		if(idRemito != -1){
			
			Iterator renglones = remito.getRenglonRemitoProvisionInsumos().iterator();
			
			while(renglones.hasNext()){
				
				RenglonRemitoProvisionInsumoDTO renglon = (RenglonRemitoProvisionInsumoDTO) renglones.next();
				
				int idInsumo = adminInsumo.getIdInsumo(renglon.getInsumo().getNombre(), renglon.getInsumo().getMarca());
				insumo = adminInsumo.getInsumoCompleto(idInsumo, "");
		
				double cantDisponible = ((insumo.getCantidad())-(renglon.getCantidadEntregada()));
				adminInsumo.setCantInsumo(idInsumo, cantDisponible);
				
				RenglonRemitoInternoInsumoId renglonId = new RenglonRemitoInternoInsumoId(renglon.getItem(),idRemito);

				RenglonRemitoInternoInsumo renglonGuardar = new RenglonRemitoInternoInsumo();
				
				renglonGuardar.setId(renglonId);
				renglonGuardar.setInsumo(insumo);
				renglonGuardar.setCantidadEntregada(renglon.getCantidadEntregada());
				
				remitoGuardar.getRenglonRemitoInternoInsumos().add(renglonGuardar);
			}
			
			boolean result = adminAlmacen.registrarRenglonesDelRemitoProvisionInsumo(remitoGuardar);
			
			if(result == true)
				return idRemito;
			else
				return (long) -1.0;
		}
		else{
			return (long) -1.0;
		}
	}
	
	//------------------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------------
	
	@SuppressWarnings("rawtypes")
	@Override
	public RemitoProvisionInsumoDTO registrarRemitoProvisionInsumo(RemitoProvisionInsumoDTO remito,String nada) throws IllegalArgumentException{
		
		Almacen adminAlmacen = new Almacen();
		edu.server.dominio.D_Empleado adminEmpleado = new edu.server.dominio.D_Empleado();
		Estado adminEstado = new Estado();
		Produccion adminProd = new Produccion();
		Insumos adminInsumo = new Insumos();
		Insumo insumo = new Insumo();
		
		int idEstado = adminEstado.getIdEstado(remito.getEstadoOrden());
		EstadoOrden est = adminEstado.getEstadoCompleto(idEstado);
		
		int idEmpleado = adminEmpleado.getIdEmpleado(remito.getEmpleado());
		Empleado emp = adminEmpleado.getEmpleado(idEmpleado);
		
		OrdenProvisionInsumo opi = new OrdenProvisionInsumo();
		opi = adminProd.getOrdenProvisionInsumoSegunId(remito.getIdOrdenProvisionInsumo());
		
		RemitoInternoInsumo remitoGuardar = new RemitoInternoInsumo();
		remitoGuardar.setEmpleado(emp);
		remitoGuardar.setEstadoOrden(est);
		remitoGuardar.setFechaCierre(remito.getFechaCierre());
		remitoGuardar.setFechaEdicion(remito.getFechaEdicion());
		remitoGuardar.setFechaGenaracion(remito.getFechaGenaracion());
		remitoGuardar.setObservaciones(remito.getObservaciones());
		remitoGuardar.setOrdenProvisionInsumo(opi);
		
		long idRemito = adminAlmacen.registrarRemitoProvisionInsumo(remitoGuardar); 
		
		if(idRemito != -1){
			
			Iterator renglones = remito.getRenglonRemitoProvisionInsumos().iterator();
			
			while(renglones.hasNext()){
				
				RenglonRemitoProvisionInsumoDTO renglon = (RenglonRemitoProvisionInsumoDTO) renglones.next();
				
				int idInsumo = adminInsumo.getIdInsumo(renglon.getInsumo().getNombre(), renglon.getInsumo().getMarca());
				insumo = adminInsumo.getInsumoCompleto(idInsumo, "");
						
				double cantDisponible = ((insumo.getCantidad())-(renglon.getCantidadEntregada()));
				
				if(cantDisponible<insumo.getStockSeguridad()){
					adminInsumo.setNecesidadCompraEnUno(idInsumo);
				}
				
				adminInsumo.setCantInsumo(idInsumo, cantDisponible);
				
				RenglonRemitoInternoInsumoId renglonId = new RenglonRemitoInternoInsumoId(renglon.getItem(),idRemito);

				RenglonRemitoInternoInsumo renglonGuardar = new RenglonRemitoInternoInsumo();
				
				renglonGuardar.setId(renglonId);
				renglonGuardar.setInsumo(insumo);
				renglonGuardar.setCantidadEntregada(renglon.getCantidadEntregada());
				
				remitoGuardar.getRenglonRemitoInternoInsumos().add(renglonGuardar);
			}
			
			boolean result = adminAlmacen.registrarRenglonesDelRemitoProvisionInsumo(remitoGuardar);
			
			if(result == true){
				
				RemitoProvisionInsumoDTO remitoDevolver = new RemitoProvisionInsumoDTO();
				remitoDevolver = this.getOrdenRemitoInternoInsumoSegunId(idRemito);
				return remitoDevolver;
			}
			else{
				RemitoProvisionInsumoDTO remitoDevolver = new RemitoProvisionInsumoDTO();
				remitoDevolver = null;
				return remitoDevolver;
			}
		}
		else{
			RemitoProvisionInsumoDTO remitoDevolver = new RemitoProvisionInsumoDTO();
			remitoDevolver = null;
			return remitoDevolver;
		}
	}

	@Override
	public List<Long> idsRemitosInternosInsumos() throws IllegalArgumentException{
		Produccion adminProd = new Produccion();
		List<Long> result = new LinkedList<Long>();
		for (RemitoInternoInsumo remito : adminProd.getRemitosInternosInsumos()) {
			result.add(remito.getIdRemitoInsumo());	
		}
		return result;	
	}
	
	@Override
	public List<Long> getRemitosInternosInsumosGenerados() throws IllegalArgumentException{
		Produccion adminProd = new Produccion();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("GENERADA");
		List<Long> result = new LinkedList<Long>();
		for (RemitoInternoInsumo remito : adminProd.getRemitosInternosInsumosGenerados(est)) {
			result.add(remito.getIdRemitoInsumo());	
		}
		return result;	
	}	
	
	@SuppressWarnings("rawtypes")
	@Override
	public RemitoProvisionInsumoDTO getOrdenRemitoInternoInsumoSegunId(Long id) throws IllegalArgumentException{

		Produccion adminProduccion = new Produccion();
		Estado adminEstado = new Estado();
		edu.server.dominio.D_Empleado adminEmpleado = new edu.server.dominio.D_Empleado();
		Insumos adminInsumo = new Insumos();
		
		RemitoProvisionInsumoDTO remitoResult = new RemitoProvisionInsumoDTO();
		RemitoInternoInsumo remitoBuscado = new RemitoInternoInsumo();
		remitoBuscado = adminProduccion.getRemitoInternoInsumoSegunId(id);
		
		String est = adminEstado.getNombreEstado(remitoBuscado.getEstadoOrden().getIdEstadoOrden());
		String emp = adminEmpleado.getNobreYApellidoEmpleado(remitoBuscado.getEmpleado().getIdEmpleado());
		
		remitoResult.setFechaCierre(remitoBuscado.getFechaCierre());
		remitoResult.setFechaEdicion(remitoBuscado.getFechaEdicion());
		remitoResult.setFechaGenaracion(remitoBuscado.getFechaGenaracion());
		remitoResult.setEstadoOrden(est);
		remitoResult.setEmpleado(emp);
		remitoResult.setObservaciones(remitoBuscado.getObservaciones());
		remitoResult.setIdRemitoInsumo(id);
		remitoResult.setIdOrdenProvisionInsumo(remitoBuscado.getOrdenProvisionInsumo().getIdOrdenProvisionInsumo());
		
		Iterator renglones = remitoBuscado.getRenglonRemitoInternoInsumos().iterator();
		
		while(renglones.hasNext()){
			
			RenglonRemitoInternoInsumo renglonBuscado = (RenglonRemitoInternoInsumo) renglones.next();
			RenglonRemitoProvisionInsumoDTO renglonResult = new RenglonRemitoProvisionInsumoDTO();
			int idRenglon = ((RenglonRemitoInternoInsumoId)renglonBuscado.getId()).getIdRenglonRemitoInsumo();
		
			InsumoDTO insumoResult = new InsumoDTO();
			Insumo insumoBuscado = new Insumo();

			insumoBuscado = adminInsumo.getInsumoCompleto(renglonBuscado.getInsumo().getIdInsumo(), "");
			insumoResult.setNombre(insumoBuscado.getNombre());
			insumoResult.setMarca(insumoBuscado.getMarca().getNombre());
			
			renglonResult.setCantidadEntregada(renglonBuscado.getCantidadEntregada());
			renglonResult.setInsumo(insumoResult);
			renglonResult.setItem(idRenglon);
						
			remitoResult.getRenglonRemitoProvisionInsumos().add(renglonResult);		
		}
		
		return remitoResult;
		
		
	}
		
	@Override
	public Boolean validarOrdenesProvisionInsumos(List<Long> listaOrdenes) throws IllegalArgumentException{
		
		Boolean result = true;
		Produccion adminProduccion = new Produccion();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("VALIDADA");
		
		for (Long nroOrden : listaOrdenes) {
			
			result = adminProduccion.validarOrdenProvisionInsumos(nroOrden,est);
			if(result == false)
				break;
	
		}
		return result;
	}

	@Override
	public Boolean cancelarOrdenesProvisionInsumos(List<Long> listaOrdenes) throws IllegalArgumentException{
		
		Boolean result = true;
		Produccion adminProduccion = new Produccion();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("CANCELADA");
		
		for (Long nroOrden : listaOrdenes) {
			
			result = adminProduccion.cancelarOrdenesProvisionInsumos(nroOrden,est);
			if(result == false)
				break;
	
		}
		return result;
	}
	
	@Override
	public Boolean cerrarRemitoProvisionInsumos(RemitoProvisionInsumoDTO remito, String fecha) throws IllegalArgumentException{
				
		Produccion adminProduccion = new Produccion();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("CERRADA");
		
		return adminProduccion.cerrarRemitoProvisionInsumos(remito.getIdRemitoInsumo(),est,fecha);

	}
	
	//------------------------------------------------------------------------------------------------------------------------
	//------- Acá tengo q sumar al almacen los insumos q fueron cancelados ---------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------------
	
	@SuppressWarnings("rawtypes")
	@Override
	public Boolean cancelarRemitoProvisionInsumos(RemitoProvisionInsumoDTO remito, String fecha) throws IllegalArgumentException{
				
		Produccion adminProduccion = new Produccion();
		Insumos adminInsumo = new Insumos();
		Insumo insumo = new Insumo();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("CANCELADA");
		
		Iterator renglones = remito.getRenglonRemitoProvisionInsumos().iterator();
		
		while(renglones.hasNext()){
			
			RenglonRemitoProvisionInsumoDTO renglon = (RenglonRemitoProvisionInsumoDTO) renglones.next();
			
			int idInsumo = adminInsumo.getIdInsumo(renglon.getInsumo().getNombre(), renglon.getInsumo().getMarca());
			insumo = adminInsumo.getInsumoCompleto(idInsumo, "");
					
			double cantDisponible = ((insumo.getCantidad())+(renglon.getCantidadEntregada()));
			
			if(cantDisponible>insumo.getStockSeguridad()){
				adminInsumo.setNecesidadCompraEnCero(idInsumo);
			}
			
			adminInsumo.setCantInsumo(idInsumo, cantDisponible);
			
		}
		
		return adminProduccion.cancelarRemitoProvisionInsumos(remito.getIdRemitoInsumo(),est,fecha);

	}
	
	//------------------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------------
		
	@Override
	public double getCantInsumo(InsumoDTO insumo) throws IllegalArgumentException{
		
		@SuppressWarnings("unused")
		double cantidadDisponible = 0;
		Insumos adminInsumos = new Insumos();
		Insumo insumoResult = new Insumo();
		int idInsumo = adminInsumos.getIdInsumo(insumo.getNombre(), insumo.getMarca());
		insumoResult = adminInsumos.getInsumoCompleto(idInsumo, "");
		int cantDisponible = insumoResult.getCantidad();
		return cantDisponible;
		
	}
	
	@Override
	public List<UsuarioCompDTO> getUsuariosSupervisoresYGerenteProduccion() throws IllegalArgumentException{
		
		Administrador admin = new Administrador();
		List<UsuarioCompDTO> usuarioSupervisores = new LinkedList<UsuarioCompDTO>();
		usuarioSupervisores = admin.getUsuariosSegunRol("SUPERVISOR");
		List<UsuarioCompDTO> usuarioGerente = new LinkedList<UsuarioCompDTO>();
		usuarioGerente = admin.getUsuariosSegunRol("GERENTE DE PRODUCCION");
		List<UsuarioCompDTO> result = new LinkedList<UsuarioCompDTO>();
		for (UsuarioCompDTO usuario : usuarioSupervisores) {
			result.add(usuario);
		}
		for (UsuarioCompDTO usuario : usuarioGerente) {
			result.add(usuario);
		}
		
		return result;
	
	}
	
	@Override
	public List<UsuarioCompDTO> getUsuariosConRolAlmacen() throws IllegalArgumentException{
		
		Administrador admin = new Administrador();
		List<UsuarioCompDTO> usuarioAlmacen = new LinkedList<UsuarioCompDTO>();
		usuarioAlmacen = admin.getUsuariosSegunRol("ALMACEN");
		List<UsuarioCompDTO> result = new LinkedList<UsuarioCompDTO>();
		for (UsuarioCompDTO usuario : usuarioAlmacen) {
			result.add(usuario);
		}
		return result;
	}
		
	@Override
	public List<UsuarioCompDTO> getUsuariosSupervisoresDeUnJefeDeFabrica(String nomUsu, String apeUsu) throws IllegalArgumentException{
		
		Administrador admin = new Administrador();
		edu.server.dominio.D_Empleado emp = new edu.server.dominio.D_Empleado();
		UsuarioCompDTO jefeDeFabrica = new UsuarioCompDTO();
		
		List<UsuarioCompDTO> usuarioJefeDeFabrica = new LinkedList<UsuarioCompDTO>();
		usuarioJefeDeFabrica = admin.getUsuariosSegunRol("JEFE DE FABRICA");
		
		List<UsuarioCompDTO> result = new LinkedList<UsuarioCompDTO>();
		for (UsuarioCompDTO usuario : usuarioJefeDeFabrica) {		
			if(usuario.getApellidoEmp().compareTo(apeUsu)==0 && usuario.getNombreEmp().compareTo(nomUsu)==0){
				jefeDeFabrica = usuario;
				result.add(usuario);
			}
		}
		
		int idEmpJefeDeFabrica = emp.getIdEmpleado(jefeDeFabrica.getNombreEmp(), jefeDeFabrica.getApellidoEmp(), "JEFE DE FABRICA");
				
		List<UsuarioCompDTO> usuarioSupervisores = new LinkedList<UsuarioCompDTO>();
		usuarioSupervisores = admin.getUsuariosSegunRol("SUPERVISOR");
		
		for (UsuarioCompDTO usuario : usuarioSupervisores) {				
			
			//agregamos los supervisores al mando del jefe de fabrica pasado como parametro
			
			int idEmpleado = emp.getIdEmpleado(usuario.getNombreEmp(), usuario.getApellidoEmp(), "SUPERVISOR");
			
			if(emp.elEmpleadoUnoEsJefeDeFabricaDelEmpleadoDosQueEsSupervisor(idEmpJefeDeFabrica, idEmpleado))
				result.add(usuario);
		}


		
		return result;
	
	}
	
	@Override
	public List<UsuarioCompDTO> getUsuariosJefeDeFabricaYSupervisoresDeUnGerenteDeProduccion() throws IllegalArgumentException{
		
		Administrador admin = new Administrador();
		
		List<UsuarioCompDTO> usuarioSupervisores = new LinkedList<UsuarioCompDTO>();	
		usuarioSupervisores = admin.getUsuariosSegunRol("SUPERVISOR");

		List<UsuarioCompDTO> usuarioJefeDeFabrica = new LinkedList<UsuarioCompDTO>();
		usuarioJefeDeFabrica = admin.getUsuariosSegunRol("JEFE DE FABRICA");
		
		List<UsuarioCompDTO> usuarioGerente = new LinkedList<UsuarioCompDTO>();
		usuarioGerente = admin.getUsuariosSegunRol("GERENTE DE PRODUCCION");
		
		
		List<UsuarioCompDTO> result = new LinkedList<UsuarioCompDTO>();
		for (UsuarioCompDTO usuario : usuarioSupervisores) {
			result.add(usuario);
		}
		for (UsuarioCompDTO usuario : usuarioJefeDeFabrica) {
			result.add(usuario);
		}
		for (UsuarioCompDTO usuario : usuarioGerente) {
			result.add(usuario);
		}
		
		return result;
	
	}
	
	@Override
	public boolean cerrarOrdenesProvision(String fecha) throws IllegalArgumentException{
			
		boolean retorno = false;
		Estado adminEstados = new Estado();
		int idEstado = adminEstados.getIdEstado("VALIDADA");
		Produccion adminProd = new Produccion();
		
		List<OrdenProvisionInsumoDTO> listaResult = new LinkedList<OrdenProvisionInsumoDTO>();
		List<OrdenProvisionInsumo> result = new LinkedList<OrdenProvisionInsumo>();
		List<Long> listaIdOrdenesProvisionInsumosACerrar = new LinkedList<Long>();
		
		result = adminProd.getOrdenProvisionInsumo(idEstado,0,0,"","");
		
		for (OrdenProvisionInsumo orden : result) {
			
			OrdenProvisionInsumoDTO ordendto = new OrdenProvisionInsumoDTO();
			ordendto = this.getOrdenProvisionInsumoSegunId(orden.getIdOrdenProvisionInsumo());
			
			listaResult.add(ordendto);
			
		}
		
		
		for (OrdenProvisionInsumoDTO orden : listaResult) {
			
			long idOrden = orden.getIdOrdenProvisionInsumo();
			
			List<Long> listaIdRemitos = new LinkedList<Long>();
			
			listaIdRemitos = this.getRemitosInternosInsumosSegunIdOrdenProvision(idOrden);
			
			List<RemitoProvisionInsumoDTO> listaRemitos = new LinkedList<RemitoProvisionInsumoDTO>();
			
			for (int i = 0; i < listaIdRemitos.size(); i++){
				
				long idRemito = listaIdRemitos.get(i);
				RemitoProvisionInsumoDTO remito = new RemitoProvisionInsumoDTO();
				remito = this.getOrdenRemitoInternoInsumoSegunId(idRemito);
				listaRemitos.add(remito);
				
			}
			
			List<InsumoDTO> insumosRemitos = new LinkedList<InsumoDTO>();
			List<InsumoDTO> insumosRemitosFinal = new LinkedList<InsumoDTO>();
			
			for (RemitoProvisionInsumoDTO remito : listaRemitos) {
				
				for (RenglonRemitoProvisionInsumoDTO renglon : remito.getRenglonRemitoProvisionInsumos()) {
				
					String nombreInsumo = ((InsumoDTO)renglon.getInsumo()).getNombre();
					String marcaInsumo = ((InsumoDTO)renglon.getInsumo()).getMarca();
					
					InsumoDTO nuevoInsumo = new InsumoDTO();
					nuevoInsumo.setNombre(nombreInsumo);
					nuevoInsumo.setMarca(marcaInsumo);
					nuevoInsumo.setCantidad((int)renglon.getCantidadEntregada());
					
					insumosRemitos.add(nuevoInsumo);
					
				}
			}
			
			for (int k = 0; k < insumosRemitos.size(); k++){
				
				boolean bandera = true;
				
				for (int h = 0; h < insumosRemitosFinal.size(); h++){
					
					String nombreDuplicado = insumosRemitos.get(k).getNombre();
					String marcaDuplicado = insumosRemitos.get(k).getMarca();
					String nombreFinal = insumosRemitosFinal.get(h).getNombre();
					String marcaFinal = insumosRemitosFinal.get(h).getMarca();
					
					if(nombreDuplicado.compareTo(nombreFinal) == 0 && marcaDuplicado.compareTo(marcaFinal) == 0){
						bandera = false;
						break;
					}
				}
				
				if(bandera == true){
					
					InsumoDTO nuevoInsumo = new InsumoDTO();
					nuevoInsumo.setNombre(insumosRemitos.get(k).getNombre());
					nuevoInsumo.setMarca(insumosRemitos.get(k).getMarca());
					nuevoInsumo.setCantidad(0);
					insumosRemitosFinal.add(nuevoInsumo);
				}
			}
			
			for (int p = 0; p < insumosRemitos.size(); p++){
				
				for(int n = 0; n < insumosRemitosFinal.size(); n++){
					
					String nombreDuplicado = insumosRemitos.get(p).getNombre();
					String marcaDuplicado = insumosRemitos.get(p).getMarca();
					String nombreFinal = insumosRemitosFinal.get(n).getNombre();
					String marcaFinal = insumosRemitosFinal.get(n).getMarca();
					
					if(nombreDuplicado.compareTo(nombreFinal) == 0 && marcaDuplicado.compareTo(marcaFinal) == 0){
						
						int cant = insumosRemitos.get(p).getCantidad();
						insumosRemitosFinal.get(n).setCantidad(insumosRemitosFinal.get(n).getCantidad()+cant);
						break;
					}
				}
			}
			
			
			for (RenglonOrdenProvisionInsumoDTO renglon : orden.getRenglonOrdenProvisionInsumos()) {
				
				for (InsumoDTO insumo : insumosRemitosFinal) {
					
					String nombreInsumoRenglon = ((InsumoDTO)renglon.getInsumo()).getNombre();
					String marcaInsumoRenglon = ((InsumoDTO)renglon.getInsumo()).getMarca();
					String nombreInsumo = insumo.getNombre();
					String marcaInsumo = insumo.getMarca();
					
					if(nombreInsumoRenglon.compareTo(nombreInsumo) == 0 && marcaInsumoRenglon.compareTo(marcaInsumo) == 0){
						renglon.setCantidadRequerida(renglon.getCantidadRequerida()-insumo.getCantidad());
					}
				}
			}
			
			boolean banderita = false;
			
			for (RenglonOrdenProvisionInsumoDTO renglon : orden.getRenglonOrdenProvisionInsumos()) {
				
				if(renglon.getCantidadRequerida() != 0){
					banderita = true;
					break;
				}
			}
			
			if(banderita == false){
				
				listaIdOrdenesProvisionInsumosACerrar.add(orden.getIdOrdenProvisionInsumo());
			}
			
		}
		
		
		for (Long id : listaIdOrdenesProvisionInsumosACerrar) {
			
			int est = adminEstados.getIdEstado("CERRADA");
			
			adminProd.cerrarOrdenesProvisionInsumos(id, est, fecha);
			
			retorno = true;
		}
		
		return retorno;
		
	}
		
	@Override
	public List<Long> getRemitosInternosInsumosSegunIdOrdenProvision(long idOrden) throws IllegalArgumentException{
		Produccion adminProd = new Produccion();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("CERRADA");
		List<Long> result = new LinkedList<Long>();
		
		
		for (RemitoInternoInsumo remito : adminProd.getRemitosInternosInsumosCerradosDeUnaCiertaOrdenProvisionInsumo(est, idOrden)) {
			result.add(remito.getIdRemitoInsumo());	
		}
		return result;	
	}	
	
	@Override
	public List<Integer> getIdDeEmpleadoConUsuarioConRolAlmacen() throws IllegalArgumentException{
		
		List<Integer> listaIdEmpleadoAlmacen = new LinkedList<Integer>();
		List<UsuarioCompDTO> listaUsuariosAlmacen = new LinkedList<UsuarioCompDTO>();
		listaUsuariosAlmacen = this.getUsuariosConRolAlmacen();
		
		for(UsuarioCompDTO usu : listaUsuariosAlmacen){
			
			EmpleadoDTO emp = new EmpleadoDTO();
			emp = this.getEmpleado(usu.getNombreEmp(), usu.getApellidoEmp(), "ALMACEN");
			
			listaIdEmpleadoAlmacen.add(emp.getIdEmpleado());
			
		}
		
		
		return listaIdEmpleadoAlmacen;
		
	}
	
	
	/**
	 * Método que se encarga de actualizar los requerimientos de materiales para una orden de fabricación particular.
	 */
	public List<RequerimientoMaterialDTO> actualizarRequerimientoMateriales(OrdenFabricacionGeneralDTO ordenFabricacion) {
		
		List<RequerimientoMaterialDTO> listaRequerimientoMaterialesVieja = new LinkedList<RequerimientoMaterialDTO>();
		List<RequerimientoMaterialDTO> listaRequerimientoMaterialesNueva = new LinkedList<RequerimientoMaterialDTO>();
		List<RequerimientoMaterialDTO> listaRequerimientoMaterialesActualizada = new LinkedList<RequerimientoMaterialDTO>();
		
		listaRequerimientoMaterialesVieja = buscarRequerimientoMateriales(ordenFabricacion);
		
		listaRequerimientoMaterialesNueva = calcularRequerimientoMateriales(ordenFabricacion);
		
		combinarRequerimientosViejosYNuevos(ordenFabricacion, listaRequerimientoMaterialesVieja, listaRequerimientoMaterialesNueva);
		
		listaRequerimientoMaterialesActualizada = buscarRequerimientoMateriales(ordenFabricacion);
		
		return listaRequerimientoMaterialesActualizada;
	}
	
	
	/**
	 * Método que se encarga de buscar los requerimientos de materiales existentes en base de datos.
	 * @param ordenFabricacion
	 * @return
	 */
	private List<RequerimientoMaterialDTO> buscarRequerimientoMateriales(OrdenFabricacionGeneralDTO ordenFabricacion) {

		List<RequerimientoMateriales> listaRequerimientoMateriales = new LinkedList<RequerimientoMateriales>();
		List<RequerimientoMaterialDTO> listaRequerimientoMaterialesDTO = new LinkedList<RequerimientoMaterialDTO>();
		
		Produccion adminProduccion = new Produccion();
		
		listaRequerimientoMateriales = adminProduccion.buscarRequerimientoMaterialesPorOrdenFabricacion(ordenFabricacion.getNroOrden());
		
		for (RequerimientoMateriales requerimientoMaterial : listaRequerimientoMateriales) {
			
			//Creamos el requerimiento de material.
			RequerimientoMaterialDTO requerimientoMaterialDTO = new RequerimientoMaterialDTO();
			requerimientoMaterialDTO.setIdRequerimientoMaterial(requerimientoMaterial.getIdRequerimientoMateriales());
			
			requerimientoMaterialDTO.setCantidadProvista(requerimientoMaterial.getCantidadProvista());
			requerimientoMaterialDTO.setFechaEstimadaInicio(requerimientoMaterial.getFechaEstimadaInicio());
			requerimientoMaterialDTO.setIdOrdenFabricacionGeneral(ordenFabricacion.getNroOrden());
			requerimientoMaterialDTO.setRequerimientoCompras(new LinkedList<RequerimientoCompraDTO>());
			requerimientoMaterialDTO.setReservaProductos(new LinkedList<ReservaProductoDTO>());
			requerimientoMaterialDTO.setProcesado(false);
			
			//Creamos el producto para asignarselo al requerimiento de material.
			ProductoDTO productoDTO = new ProductoDTO();
			productoDTO.setIdProducto(requerimientoMaterial.getProducto().getIdProducto());
			
			//Creamos la clase del producto y se la asignamos al elemento del producto
			ClaseProductoDTO claseDTO = new ClaseProductoDTO();
			claseDTO.setCodigo(requerimientoMaterial.getProducto().getElementoProducto().getClaseProducto().getCodigoClaseProducto());
			claseDTO.setNombre(requerimientoMaterial.getProducto().getElementoProducto().getClaseProducto().getNombre());
			
			//Creamos el elemento del producto
			ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
			elementoDTO.setCodigo(requerimientoMaterial.getProducto().getElementoProducto().getId().getCodigoElementoProducto());
			elementoDTO.setClase(claseDTO);
			elementoDTO.setNombre(requerimientoMaterial.getProducto().getElementoProducto().getNombre());
			elementoDTO.setTipoDimension(requerimientoMaterial.getProducto().getElementoProducto().getTipoDimension());
			productoDTO.setElemento(elementoDTO);
			
			//Creamos el material y se lo asignamos al producto.
			MaterialProductoDTO materialDTO = new MaterialProductoDTO();
			materialDTO.setCodigo(requerimientoMaterial.getProducto().getMaterialProducto().getCodigoMaterialProducto());
			materialDTO.setNombre(requerimientoMaterial.getProducto().getMaterialProducto().getNombre());
			productoDTO.setMaterial(materialDTO);
			
			//Creamos la medida fija y se la asignamos al producto
			MedidaFijaProductoDTO medidaFija = new MedidaFijaProductoDTO();
			medidaFija.setCodigo(requerimientoMaterial.getProducto().getMedidaFijaProducto().getCodigoMedidaFijaProducto());
			medidaFija.setMedida(requerimientoMaterial.getProducto().getMedidaFijaProducto().getMedida());
			productoDTO.setMedidaFija(medidaFija);
			
			//Cargamos las medidas variables del producto
			for(MedidasVariablesEstandar medidaVariable : requerimientoMaterial.getProducto().getMedidasVariablesEstandars())
			{
				MedidaVariableEstandarDTO medidaVariableDTO = new MedidaVariableEstandarDTO();
									
				medidaVariableDTO.setMedidaVariable1((float) medidaVariable.getId().getMedidaVariable1());
				medidaVariableDTO.setMedidaVariable2((float) medidaVariable.getId().getMedidaVariable2());
				
				productoDTO.getMedidasEstandar().add(medidaVariableDTO);
			}
			
			requerimientoMaterialDTO.setProducto(productoDTO);
			
			//Creamos los detalles de requerimientos de materiales para asignarselos al requerimiento de material.
			List<DetalleRequerimientoMaterialesDTO> listaDetalleRequerimientoMateriales = new LinkedList<DetalleRequerimientoMaterialesDTO>();
			
			for (DetalleRequerimientoMateriales detalleRequerimientoMateriales : requerimientoMaterial.getDetalleRequerimientoMaterialeses()) {
				
				DetalleRequerimientoMaterialesDTO detalleRequerimientoMaterialesDTO = new DetalleRequerimientoMaterialesDTO();
				
				detalleRequerimientoMaterialesDTO.setIdDetalleRequerimientoMateriales(detalleRequerimientoMateriales.getIdDetalleRequerimientoMateriales());
				detalleRequerimientoMaterialesDTO.setCantidad(detalleRequerimientoMateriales.getCantidad());
				detalleRequerimientoMaterialesDTO.setMedidaVariable1(detalleRequerimientoMateriales.getMedidaVariable1());
				detalleRequerimientoMaterialesDTO.setMedidaVariable2(detalleRequerimientoMateriales.getMedidaVariable2());
				detalleRequerimientoMaterialesDTO.setProcesado(false);
				
				listaDetalleRequerimientoMateriales.add(detalleRequerimientoMaterialesDTO);
			}
			
			requerimientoMaterialDTO.setListaMaterialesRequeridos(listaDetalleRequerimientoMateriales);
			
			listaRequerimientoMaterialesDTO.add(requerimientoMaterialDTO);
		}
		
		return listaRequerimientoMaterialesDTO;
	}
	
	
	/**
	 * Método que calcula los requerimientos de materiales para una orden de fabricación en particular.
	 * En caso de que ya se hayan calculado alguna vez, los actualiza.
	 */
	public List<RequerimientoMaterialDTO> calcularRequerimientoMateriales(OrdenFabricacionGeneralDTO ordenFabricacion) {
		
		IngenieriaServiceImpl ingenieria = new IngenieriaServiceImpl();
		
		Queue<RenglonListaMaterialesDTO> listaEquiposYComponentesDTO = new LinkedList<RenglonListaMaterialesDTO>();
		List<RequerimientoMaterialDTO> listaRequerimientosDTO = new LinkedList<RequerimientoMaterialDTO>();
		
		//Para los renglones de la orden de fabricación, generamos espuriamente renglones de lista de materiales que serán el puntapié inicial para
		//generar los requerimientos.
		for (RenglonOrdenFabricacionGeneralDTO renglonOrdenFabricacion : ordenFabricacion.getRenglonOrdenFabricacionGeneralsDTO()) {
			
			RenglonListaMaterialesDTO renglonListaMateriales = new RenglonListaMaterialesDTO();
			
			renglonListaMateriales.setIdListaMateriales(renglonOrdenFabricacion.getRenglonOrdenPedidoDTO().getIdListaMateriales());
			renglonListaMateriales.setCantidad(renglonOrdenFabricacion.getCantidadAProducir());
			renglonListaMateriales.setFechaEstimadaInicio(renglonOrdenFabricacion.getFechaEstimadaInicio());
			renglonListaMateriales.setTipoRenglon(renglonOrdenFabricacion.getRenglonOrdenPedidoDTO().getEquipoOComponente());
			
			if (renglonListaMateriales.getTipoRenglon().equals("EQUIPO")) {
				
				String codigoEquipoOComponente = renglonOrdenFabricacion.getRenglonOrdenPedidoDTO().getCodigo();
				
				int codigoClase = Integer.parseInt(codigoEquipoOComponente.split("-")[0].substring(0, 2));
				int codigoSubclase = Integer.parseInt(codigoEquipoOComponente.split("-")[0].substring(2, 4));
				String version = codigoEquipoOComponente.split("-")[1];
				int plano = Integer.parseInt(codigoEquipoOComponente.split("-")[3]);
				
				renglonListaMateriales.setEquipoPatronDTO(ingenieria.buscarEquipoPatron(codigoClase, codigoSubclase, plano, version));
			}
			
			else {
				
				String codigoEquipoOComponente = renglonOrdenFabricacion.getRenglonOrdenPedidoDTO().getCodigo();
				
				int codigoClase = Integer.parseInt(codigoEquipoOComponente.split("-")[0].substring(0, 2));
				int codigoSubclase = Integer.parseInt(codigoEquipoOComponente.split("-")[0].substring(2, 4));
				String version = codigoEquipoOComponente.split("-")[1];
				int codigoComponente = Integer.parseInt(codigoEquipoOComponente.split("-")[2].substring(0, 2));
				int codigoSubcomponente = Integer.parseInt(codigoEquipoOComponente.split("-")[2].substring(2, 4));
				int plano = Integer.parseInt(codigoEquipoOComponente.split("-")[3]);
			
				renglonListaMateriales.setComponentePatronDTO(ingenieria.buscarComponentePatron(codigoClase, codigoSubclase, version, codigoComponente, codigoSubcomponente, plano));
			}		
			
			listaEquiposYComponentesDTO.add(renglonListaMateriales);
		}
		
		//Para cada equipo y componente...
		while (!listaEquiposYComponentesDTO.isEmpty()) {
			
			RenglonListaMaterialesDTO renglonListaMaterialesPrincipal = listaEquiposYComponentesDTO.remove();
			
			//...se busca la lista de materiales del equipo o componente.
			ListaDeMaterialesDTO lista = ingenieria.buscarListaMateriales(renglonListaMaterialesPrincipal.getIdListaMateriales());
			
			for (RenglonListaMaterialesDTO renglonListaMaterialesSecundaria: lista.getRenglonListaMaterialesesDTO()) {
				
				//Si el renglón de la lista de materiales contiene un equipo o componente, se lo agrega al array de equipos y componentes.
				if (renglonListaMaterialesSecundaria.getTipoRenglon().equals("EQUIPO") || renglonListaMaterialesSecundaria.getTipoRenglon().equals("COMPONENTE")) {	
					
					renglonListaMaterialesSecundaria.setFechaEstimadaInicio(renglonListaMaterialesPrincipal.getFechaEstimadaInicio());
					renglonListaMaterialesSecundaria.setCantidad(renglonListaMaterialesSecundaria.getCantidad() * renglonListaMaterialesPrincipal.getCantidad());
					listaEquiposYComponentesDTO.add(renglonListaMaterialesSecundaria);
				}				
				
				//Si el renglón de la lista de materiales contiene un material, se lo agrega al array de requerimiento de materiales.
				else {
					
					RequerimientoMaterialDTO requerimientoMaterialDTO = new RequerimientoMaterialDTO();
					requerimientoMaterialDTO.setProcesado(false);
					
					/////Identificador del requerimiento de material (va a identificar unívocamente cada registro en el array requerimientosDTO).
					requerimientoMaterialDTO.setIdOrdenFabricacionGeneral(ordenFabricacion.getNroOrden());
					requerimientoMaterialDTO.setFechaEstimadaInicio(renglonListaMaterialesPrincipal.getFechaEstimadaInicio());
					requerimientoMaterialDTO.setProducto(renglonListaMaterialesSecundaria.getProductoDTO());
					/////
					
					List<DetalleRequerimientoMaterialesDTO> listaDetalleRequerimientoMaterial = new LinkedList<DetalleRequerimientoMaterialesDTO>();
					
					DetalleRequerimientoMaterialesDTO detalleRequerimientoMaterial = new DetalleRequerimientoMaterialesDTO();
					detalleRequerimientoMaterial.setMedidaVariable1(renglonListaMaterialesSecundaria.getMedida1());
					if ((renglonListaMaterialesSecundaria.getMedida2() == null) || (renglonListaMaterialesSecundaria.getMedida2() == 0))
						detalleRequerimientoMaterial.setMedidaVariable2(0.0);
					else
						detalleRequerimientoMaterial.setMedidaVariable2(renglonListaMaterialesSecundaria.getMedida2());
					detalleRequerimientoMaterial.setCantidad(renglonListaMaterialesSecundaria.getCantidad() * renglonListaMaterialesPrincipal.getCantidad());
					detalleRequerimientoMaterial.setProcesado(false);
					
					listaDetalleRequerimientoMaterial.add(detalleRequerimientoMaterial);
					
					requerimientoMaterialDTO.setListaMaterialesRequeridos(listaDetalleRequerimientoMaterial);
					
					clasificarRequerimientoMateriales(requerimientoMaterialDTO, listaRequerimientosDTO);
				}
			}
		}
		
		return listaRequerimientosDTO;
	}
	
	/**
	 * Método que clasifica el requerimiento de material pasado como primer parámetro, en la lista de requerimientos de materiales pasada como segundo parámetro.
	 * @param requerimientoMaterial
	 * @param listaRequerimientos
	 */
	public void clasificarRequerimientoMateriales(RequerimientoMaterialDTO requerimientoMaterial, List<RequerimientoMaterialDTO> listaRequerimientos) {
		
		int i = 0;
		boolean noExisteRequerimiento = true;
		
		// para cada requerimiento en la lista de requerimientos,
		while (i < listaRequerimientos.size() && noExisteRequerimiento) {
		
			// si se encuentra que ya existe un requerimiento con igual id orden fabricación, fecha estimada de inicio y producto
			if (requerimientoMaterial.getFechaEstimadaInicio().compareTo(listaRequerimientos.get(i).getFechaEstimadaInicio()) == 0 &&
					requerimientoMaterial.getProducto().getIdProducto() == listaRequerimientos.get(i).getProducto().getIdProducto()) {
				
				int j = 0;
				boolean noExisteMedida = true;
				
				// para cada detalle en la lista de detalles de requerimientos,
				while (j < listaRequerimientos.get(i).getListaMaterialesRequeridos().size() && noExisteMedida) {
					
					// si se encuentra que ya existe un detalle requerimiento con iguales medidas variables, se realiza una suma simple en la cantidad requerida
					if ((requerimientoMaterial.getListaMaterialesRequeridos().get(0).getMedidaVariable1().compareTo(listaRequerimientos.get(i).getListaMaterialesRequeridos().get(j).getMedidaVariable1()) == 0 &&
							requerimientoMaterial.getListaMaterialesRequeridos().get(0).getMedidaVariable2().compareTo(listaRequerimientos.get(i).getListaMaterialesRequeridos().get(j).getMedidaVariable2()) == 0)
							||
							(requerimientoMaterial.getListaMaterialesRequeridos().get(0).getMedidaVariable1().compareTo(listaRequerimientos.get(i).getListaMaterialesRequeridos().get(j).getMedidaVariable2()) == 0 &&
							 requerimientoMaterial.getListaMaterialesRequeridos().get(0).getMedidaVariable2().compareTo(listaRequerimientos.get(i).getListaMaterialesRequeridos().get(j).getMedidaVariable1()) == 0)) {
						
						listaRequerimientos.get(i).getListaMaterialesRequeridos().get(j).setCantidad(
								listaRequerimientos.get(i).getListaMaterialesRequeridos().get(j).getCantidad() + 
								requerimientoMaterial.getListaMaterialesRequeridos().get(0).getCantidad());
						
						noExisteMedida = false;
					}
					
					j++;
				}
				
				// si no existen iguales medidas variables, se agrega un nuevo detalle con las nuevas medidas
				if (noExisteMedida) {
					listaRequerimientos.get(i).getListaMaterialesRequeridos().add(requerimientoMaterial.getListaMaterialesRequeridos().get(0));
				}
				
				noExisteRequerimiento = false;
			}
			
			i++;
		}
		
		// si no existe un requerimiento con el identificador mencionado, se agrega el nuevo requerimiento
		if (noExisteRequerimiento) {
			
			listaRequerimientos.add(requerimientoMaterial);
		}
	}
	
	
	/**
	 * Método que se encarga de combinar las listas de materiales viejas y las nuevas.
	 * @param listaRequerimientoMaterialesVieja
	 * @param listaRequerimientoMaterialesNueva
	 * @return
	 */
	public void combinarRequerimientosViejosYNuevos(OrdenFabricacionGeneralDTO ordenFabricacion, List<RequerimientoMaterialDTO> listaRequerimientoMaterialesVieja, List<RequerimientoMaterialDTO> listaRequerimientoMaterialesNueva) {
		
		Produccion adminProduccion = new Produccion();
		
		for(RequerimientoMaterialDTO requerimientoMaterialViejo : listaRequerimientoMaterialesVieja) {
			for(RequerimientoMaterialDTO requerimientoMaterialNuevo : listaRequerimientoMaterialesNueva) {
				
				//Si los productos y las fechas para la que se requieren son iguales...
				if((requerimientoMaterialViejo.getProducto().getIdProducto() == requerimientoMaterialNuevo.getProducto().getIdProducto()) &&
						(requerimientoMaterialViejo.getFechaEstimadaInicio().compareTo(requerimientoMaterialNuevo.getFechaEstimadaInicio()) == 0)) {
							
					for(DetalleRequerimientoMaterialesDTO detalleRequerimientoMaterialesViejo : requerimientoMaterialViejo.getListaMaterialesRequeridos()) {
						for(DetalleRequerimientoMaterialesDTO detalleRequerimientoMaterialesNuevo : requerimientoMaterialNuevo.getListaMaterialesRequeridos()) {
						
							//Si los detalles de requerimientos de materiales son iguales...
							if((detalleRequerimientoMaterialesViejo.getMedidaVariable1().compareTo(detalleRequerimientoMaterialesNuevo.getMedidaVariable1()) == 0 &&
									detalleRequerimientoMaterialesViejo.getMedidaVariable2().compareTo(detalleRequerimientoMaterialesNuevo.getMedidaVariable2()) == 0)
									||
									(detalleRequerimientoMaterialesViejo.getMedidaVariable1().compareTo(detalleRequerimientoMaterialesNuevo.getMedidaVariable2()) == 0 &&
									detalleRequerimientoMaterialesViejo.getMedidaVariable2().compareTo(detalleRequerimientoMaterialesNuevo.getMedidaVariable1()) == 0)) {
								
								//Si las cantidades son distintas, actualizamos la base de datos con la nueva cantidad.
								if(detalleRequerimientoMaterialesViejo.getCantidad() != detalleRequerimientoMaterialesNuevo.getCantidad()) {
									DetalleRequerimientoMateriales detalleRequerimientoMateriales = adminProduccion.buscarDetalleRequerimientoMateriales(requerimientoMaterialViejo.getIdRequerimientoMaterial(), detalleRequerimientoMaterialesViejo.getIdDetalleRequerimientoMateriales());
									
									detalleRequerimientoMateriales.setCantidad(detalleRequerimientoMaterialesNuevo.getCantidad());
									
									adminProduccion.actualizarCantidadDetalleRequerimientoMateriales(detalleRequerimientoMateriales);
								}
								
								detalleRequerimientoMaterialesViejo.setProcesado(true);
								detalleRequerimientoMaterialesNuevo.setProcesado(true);
							}
						}
					}
					
					requerimientoMaterialViejo.setProcesado(true);
					requerimientoMaterialNuevo.setProcesado(true);
				}
			}
		}
		
		//Se actualizan las cantidades de requerimientos de materiales viejos que no se necesitan más
		for(RequerimientoMaterialDTO requerimientoMaterialViejo : listaRequerimientoMaterialesVieja) {
			for(DetalleRequerimientoMaterialesDTO detalleRequerimientoMaterialesViejo : requerimientoMaterialViejo.getListaMaterialesRequeridos()) {
				if(!detalleRequerimientoMaterialesViejo.isProcesado()) {
					DetalleRequerimientoMateriales detalleRequerimientoMateriales = adminProduccion.buscarDetalleRequerimientoMateriales(requerimientoMaterialViejo.getIdRequerimientoMaterial(), detalleRequerimientoMaterialesViejo.getIdDetalleRequerimientoMateriales());
					
					detalleRequerimientoMateriales.setCantidad(0);
					
					adminProduccion.actualizarCantidadDetalleRequerimientoMateriales(detalleRequerimientoMateriales);
				}
			}	
		}
		
		//Se guardan los requerimientos de materiales y los detalles nuevos.
		for(RequerimientoMaterialDTO requerimientoMaterialNuevo : listaRequerimientoMaterialesNueva) {
			
			RequerimientoMateriales requerimientoMaterial = new RequerimientoMateriales();
			
			if(!requerimientoMaterialNuevo.isProcesado()) {
				D_OrdenFabricacionGeneral adminOrden = new D_OrdenFabricacionGeneral();
				D_Producto adminProducto = new D_Producto();
				Integer idRequerimientoMaterial = 0;
				
				requerimientoMaterial.setFechaEstimadaInicio(requerimientoMaterialNuevo.getFechaEstimadaInicio());
				requerimientoMaterial.setOrdenFabricacionGeneral(adminOrden.buscarOrdenFabricacionGeneral(ordenFabricacion.getNroOrden()));
				requerimientoMaterial.setProducto(adminProducto.buscarProducto(requerimientoMaterialNuevo.getProducto().getIdProducto()));
				requerimientoMaterial.setCantidadProvista(0);
				
				idRequerimientoMaterial = adminProduccion.registrarRequerimientoMateriales(requerimientoMaterial);
				
				requerimientoMaterial = adminProduccion.buscarRequerimientoMateriales(idRequerimientoMaterial);
			}
			
			for(DetalleRequerimientoMaterialesDTO detalleRequerimientoMaterialesNuevo : requerimientoMaterialNuevo.getListaMaterialesRequeridos()) {
				
				if(!detalleRequerimientoMaterialesNuevo.isProcesado()) {
					DetalleRequerimientoMateriales detalleRequerimientoMateriales = new DetalleRequerimientoMateriales();

					detalleRequerimientoMateriales.setRequerimientoMateriales(requerimientoMaterial);
					detalleRequerimientoMateriales.setCantidad(detalleRequerimientoMaterialesNuevo.getCantidad());
					detalleRequerimientoMateriales.setMedidaVariable1(detalleRequerimientoMaterialesNuevo.getMedidaVariable1());
					detalleRequerimientoMateriales.setMedidaVariable2(detalleRequerimientoMaterialesNuevo.getMedidaVariable2());
					
					adminProduccion.registrarDetalleRequerimientoMateriales(detalleRequerimientoMateriales);
				}
			}	
		}
	}
	
	/**
	 * Método que se encarga de calcular los requerimientos actuales.
	 * @param requerimientos
	 * @return
	 */
	public List<RequerimientoMaterialDTO> calcularRequerimientosActuales(List<RequerimientoMaterialDTO> requerimientos) {
		
		for(RequerimientoMaterialDTO requerimientoSeleccionado : requerimientos) {
			
			/*
			 * Sección que se encarga de comprobar todas las medidas existentes en inventario para un producto en particular y cargarlas
			 * como posibles reservas de producto.
			 */
			
			int idProducto = requerimientoSeleccionado.getProducto().getIdProducto();
			List<InventarioDTO> listaProductosEnInventario = new LinkedList<InventarioDTO>();
			AlmacenServiceImpl adminAlmacen = new AlmacenServiceImpl();
			
			listaProductosEnInventario = adminAlmacen.buscarEnInventario(idProducto);
			
			List<ReservaProductoDTO> listaReservaProducto = new LinkedList<ReservaProductoDTO>();
			requerimientoSeleccionado.getReservaProductos().clear();
			
			//Para cada producto en inventario...
			for (int i = 0; i < listaProductosEnInventario.size(); i++) {
				
				ReservaProductoDTO reservaProducto = new ReservaProductoDTO();
				
				reservaProducto.setCantidadReservadaPendienteEntrega(0.0);
				reservaProducto.setCantidadReservada(0.0);
				
				reservaProducto.setInventario(listaProductosEnInventario.get(i));
				reservaProducto.setRequerimientoMateriales(requerimientoSeleccionado);
				listaReservaProducto.add(reservaProducto);
			}
			
			requerimientoSeleccionado.setReservaProductos(listaReservaProducto);
			
			
			/*
			 * Sección que se encarga de comprobar todas las medidas estándares existentes para un producto en particular y cargarlas
			 * como posibles requerimientos de compra.
			 */
			
			int codigoClase = requerimientoSeleccionado.getProducto().getElemento().getClase().getCodigo();
			int codigoElemento = requerimientoSeleccionado.getProducto().getElemento().getCodigo();
			int codigoMaterial = requerimientoSeleccionado.getProducto().getMaterial().getCodigo();
			List<ProductoDTO> listaProductosMedidasEstandar = new LinkedList<ProductoDTO>();
			IngenieriaServiceImpl adminIngenieria = new IngenieriaServiceImpl();
			
			listaProductosMedidasEstandar = adminIngenieria.buscarProductos(codigoClase, codigoElemento, codigoMaterial);
			
			List<RequerimientoCompraDTO> listaRequerimientoCompra = new LinkedList<RequerimientoCompraDTO>();
			requerimientoSeleccionado.getRequerimientoCompras().clear();
			
			String medidaFijaBuscada = requerimientoSeleccionado.getProducto().getMedidaFija().getMedida();
			
			ProductoDTO productoRequerido = new ProductoDTO();
			
			//Busco la medida fija que corresponde.
			for (int i = 0; i < listaProductosMedidasEstandar.size(); i++) {
				if (listaProductosMedidasEstandar.get(i).getMedidaFija().getMedida().equals(medidaFijaBuscada))
					productoRequerido = listaProductosMedidasEstandar.get(i);					
			}
			
			//Para cada medida variable estandar que existe de ese producto...
			for (int i = 0; i < productoRequerido.getMedidasEstandar().size(); i++) {
				
				//Creamos el requerimiento compra para añadirlo a la lista de requerimientos de compra.
				RequerimientoCompraDTO requerimientoCompra = new RequerimientoCompraDTO();
				
				requerimientoCompra.setMedidaVariable1(Double.parseDouble(String.valueOf(productoRequerido.getMedidasEstandar().get(i).getMedidaVariable1())));
				requerimientoCompra.setMedidaVariable2(Double.parseDouble(String.valueOf(productoRequerido.getMedidasEstandar().get(i).getMedidaVariable2())));
				requerimientoCompra.setRequerimientoMaterial(requerimientoSeleccionado);
				listaRequerimientoCompra.add(requerimientoCompra);
			}
			
			requerimientoSeleccionado.setRequerimientoCompras(listaRequerimientoCompra);
			
			
			/*
			 * Sección que se encarga de comprobar la existencia de reservas realizadas en alguna sesión anterior y cargarlas como reservas de producto.
			 */
			
			int idRequerimientoMaterial = requerimientoSeleccionado.getIdRequerimientoMaterial();
			List<ReservaProductoDTO> listaReservaProductoRealizada = new LinkedList<ReservaProductoDTO>();
			
			listaReservaProductoRealizada = buscarReservaProducto(idRequerimientoMaterial);
			
			List<ReservaProductoDTO> listaReservaProductoExistente = requerimientoSeleccionado.getReservaProductos();
			
			int i = 0;
			
			//Mientras que haya reservas de productos de la base de datos...
			while (listaReservaProductoRealizada.size() > i) {
				
				ReservaProductoDTO reservaProducto = listaReservaProductoRealizada.get(i);
				
				int j = 0;
			
				//Mientras que queden reservas de productos ya cargadas para comparar...
				while (listaReservaProductoExistente.size() > j) {
					
					ReservaProductoDTO reservaProductoExistente = listaReservaProductoExistente.get(j);
					
					//Si la reserva de productos ya existía de antes, entonces eliminamos de la lista la reserva existente.
					//De hecho, siempre va a existir esta reserva, pues son todos los productos existentes en almacén, con sus diversas medidas.
					if(((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(reservaProducto.getInventario().getMedida1()))) &&
							(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(reservaProducto.getInventario().getMedida2()))))
							||
							((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(reservaProducto.getInventario().getMedida2()))) &&
							(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(reservaProducto.getInventario().getMedida1()))))){
						
						requerimientoSeleccionado.getReservaProductos().remove(j);							
					}
					
					j++;
				}
				
				reservaProducto.setCantidadReservadaPendienteEntrega(0.0);
				
				//Agregamos la reserva realizada en otra sesión.
				requerimientoSeleccionado.getReservaProductos().add(reservaProducto);
				
				i++;
			}
			
			
			/*
			 * Sección que se encarga de comprobar la existencia de compras realizadas en alguna sesión anterior y cargarlas como requerimientos de compra.
			 * Si el requerimiento de compra no está activo, se carga como reserva de producto pendiente de entrega.
			 */
			
			List<RequerimientoCompraDTO> listaRequerimientoCompraRealizado = new LinkedList<RequerimientoCompraDTO>();
			
			listaRequerimientoCompraRealizado = buscarRequerimientoCompra(idRequerimientoMaterial);
			
			i = 0;
			
			//Mientras que haya requerimientos de compra de la base de datos...
			while (listaRequerimientoCompraRealizado.size() > i) {
				
				RequerimientoCompraDTO requerimientoCompra = listaRequerimientoCompraRealizado.get(i);
				
				//Si existe un requerimiento de compra que no está activo, se colocará como reserva en camino.
				if(!requerimientoCompra.isActivo()) {
					int j = 0;
					
					//Mientras que queden reservas de productos ya cargadas para comparar...
					while (requerimientoSeleccionado.getReservaProductos().size() > j) {
						
						ReservaProductoDTO reservaProductoExistente = requerimientoSeleccionado.getReservaProductos().get(j);
												
						//Si existe una reserva de productos con las mismas medidas, se deben actualizar las cantidades pendientes de entrega de esa reserva,
						//Siempre existirá una reserva de productos con estas medidas, ya que se hallarán en almacén sí o sí.
						if(((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(requerimientoCompra.getMedidaVariable1()))) &&
								(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(requerimientoCompra.getMedidaVariable2()))))
								||
								((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(requerimientoCompra.getMedidaVariable2()))) &&
								(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(requerimientoCompra.getMedidaVariable1()))))) {
		
							requerimientoSeleccionado.getReservaProductos().get(j).setCantidadReservadaPendienteEntrega(
									requerimientoSeleccionado.getReservaProductos().get(j).getCantidadReservadaPendienteEntrega() + requerimientoCompra.getCantidadRequerida());
						}
						
						j++;
					}
				}
									
				i++;
			}
			
			//Hacemos limpieza de las reservas que no tienen ni disponible ni reservado pendiente de entrega ni reservado.
			int reservaNro = 0;
			
			listaReservaProductoExistente = requerimientoSeleccionado.getReservaProductos();
			
			while (listaReservaProductoExistente.size() > reservaNro) {
				
				ReservaProductoDTO reservaProductoExistente = listaReservaProductoExistente.get(reservaNro);
	
				//Si no tiene disponibilidad, ni reserva en camino, ni reserva realizada, se elimina el renglón.
				if((reservaProductoExistente.getCantidadReservada().compareTo(0.0) == 0) &&
						(reservaProductoExistente.getCantidadReservadaPendienteEntrega().compareTo(0.0) == 0) &&
						(reservaProductoExistente.getInventario().getCantidadDisponible().compareTo(0.0) == 0)) {
					listaReservaProductoExistente.remove(reservaNro);							
				}
				else
					reservaNro++;
			}
			
			requerimientoSeleccionado.setReservaProductos(listaReservaProductoExistente);
			
			//Hacemos limpieza de los requerimientos de compra que no están en activas.
			int compraNro = 0;
			
			listaRequerimientoCompraRealizado = buscarRequerimientoCompra(idRequerimientoMaterial);
			List<RequerimientoCompraDTO> listaRequerimientoCompraExistente = new LinkedList<RequerimientoCompraDTO>();
			
			//Mientras que haya requerimientos de compra de la base de datos...
			while (listaRequerimientoCompraRealizado.size() > compraNro) {
				
				RequerimientoCompraDTO requerimientoCompra = listaRequerimientoCompraRealizado.get(compraNro);
				
				//Si existe un requerimiento de compra que no está activo, se lo elimina de la lista.
				if(requerimientoCompra.isActivo()) {
					listaRequerimientoCompraExistente.add(requerimientoCompra);
				}
									
				compraNro++;
			}
			
			/*
			 * Cálculo del total reservado.
			 */
			
			List<ReservaProductoDTO> listaReservaProductoTotales = requerimientoSeleccionado.getReservaProductos();
			double totalReservado = 0;
			
			for (i = 0; i < listaReservaProductoTotales.size(); i++) {
				
				//Calculamos el total reservado hasta el momento, que involucra lo reservado más lo reservado en tránsito.
				
				if (((listaReservaProductoTotales.get(i).getInventario().getMedida1().equals("0.0") || listaReservaProductoTotales.get(i).getInventario().getMedida1().equals(null))) && 
						((listaReservaProductoTotales.get(i).getInventario().getMedida2().equals("0.0") || listaReservaProductoTotales.get(i).getInventario().getMedida2().equals(null))))
					totalReservado = totalReservado + (listaReservaProductoTotales.get(i).getCantidadReservada() + listaReservaProductoTotales.get(i).getCantidadReservadaPendienteEntrega());
				else if((listaReservaProductoTotales.get(i).getInventario().getMedida2().equals("0.0") || listaReservaProductoTotales.get(i).getInventario().getMedida2().equals(null)))
					totalReservado = totalReservado + (listaReservaProductoTotales.get(i).getCantidadReservada() + listaReservaProductoTotales.get(i).getCantidadReservadaPendienteEntrega()) * Double.parseDouble(listaReservaProductoTotales.get(i).getInventario().getMedida1());
				else
					totalReservado = totalReservado + (listaReservaProductoTotales.get(i).getCantidadReservada() + listaReservaProductoTotales.get(i).getCantidadReservadaPendienteEntrega()) * Double.parseDouble(listaReservaProductoTotales.get(i).getInventario().getMedida1()) * Double.parseDouble(listaReservaProductoTotales.get(i).getInventario().getMedida2());
			}
			
			
			/*
			 * Cálculo del total solicitado.
			 */
			
			List<RequerimientoCompraDTO> listaRequerimientoCompraTotales = listaRequerimientoCompraExistente;
			double totalSolicitado = 0;
			
			for (i = 0; i < listaRequerimientoCompraTotales.size(); i++) {
				
				//Calculamos el total solicitado hasta el momento.
				if((listaRequerimientoCompraTotales.get(i).getMedidaVariable1().compareTo(0.0) == 0) && (listaRequerimientoCompraTotales.get(i).getMedidaVariable2().compareTo(0.0) == 0))
					totalSolicitado = totalSolicitado + listaRequerimientoCompraTotales.get(i).getCantidadRequerida();
				else if(listaRequerimientoCompraTotales.get(i).getMedidaVariable2().compareTo(0.0) == 0)
					totalSolicitado = totalSolicitado + listaRequerimientoCompraTotales.get(i).getCantidadRequerida() * listaRequerimientoCompraTotales.get(i).getMedidaVariable1();
				else
					totalSolicitado = totalSolicitado + listaRequerimientoCompraTotales.get(i).getCantidadRequerida() * listaRequerimientoCompraTotales.get(i).getMedidaVariable1() * listaRequerimientoCompraTotales.get(i).getMedidaVariable2();
			}
			
			
			/*
			 * Cálculo del requerimiento bruto.
			 */
			
			requerimientoSeleccionado.setRequerimientoBruto(0.0);
			
			for(int j = 0; j < requerimientoSeleccionado.getListaMaterialesRequeridos().size(); j++) {
			
				if((requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable1().compareTo(0.0) == 0) && (requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable2().compareTo(0.0) == 0))
					requerimientoSeleccionado.setRequerimientoBruto(requerimientoSeleccionado.getRequerimientoBruto() + requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getCantidad());
				else if(requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable2().compareTo(0.0) == 0)
					requerimientoSeleccionado.setRequerimientoBruto(requerimientoSeleccionado.getRequerimientoBruto() + requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable1() * requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getCantidad());
				else
					requerimientoSeleccionado.setRequerimientoBruto(requerimientoSeleccionado.getRequerimientoBruto() + requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable1() * requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable2() * requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getCantidad());
			}
					
			requerimientoSeleccionado.setCantidadReservada(totalReservado);
			requerimientoSeleccionado.setCantidadSolicitada(totalSolicitado);
			requerimientoSeleccionado.setTotalRSP(totalReservado + totalSolicitado + requerimientoSeleccionado.getCantidadProvista());
		}
		
		return requerimientos;
	}
	
	/**
	 * Método que se encarga de calcular las reservas y compras que serán cargadas en la segunda sección de la pantalla ReservarYComprar.
	 * @param requerimientoSeleccionado
	 * @return
	 */
	public RequerimientoMaterialDTO calcularReservasYCompras(RequerimientoMaterialDTO requerimientoSeleccionado) {
		
		/*
		 * Sección que se encarga de comprobar todas las medidas existentes en inventario para un producto en particular y cargarlas
		 * como posibles reservas de producto.
		 */
		
		int idProducto = requerimientoSeleccionado.getProducto().getIdProducto();
		List<InventarioDTO> listaProductosEnInventario = new LinkedList<InventarioDTO>();
		AlmacenServiceImpl adminAlmacen = new AlmacenServiceImpl();
		
		listaProductosEnInventario = adminAlmacen.buscarEnInventario(idProducto);
		
		List<ReservaProductoDTO> listaReservaProducto = new LinkedList<ReservaProductoDTO>();
		requerimientoSeleccionado.getReservaProductos().clear();
		
		//Para cada producto en inventario...
		for (int i = 0; i < listaProductosEnInventario.size(); i++) {
			
			ReservaProductoDTO reservaProducto = new ReservaProductoDTO();
			
			reservaProducto.setCantidadReservadaPendienteEntrega(0.0);
			reservaProducto.setCantidadReservada(0.0);
			
			reservaProducto.setInventario(listaProductosEnInventario.get(i));
			reservaProducto.setRequerimientoMateriales(requerimientoSeleccionado);
			listaReservaProducto.add(reservaProducto);
		}
		
		requerimientoSeleccionado.setReservaProductos(listaReservaProducto);
		
		
		/*
		 * Sección que se encarga de comprobar todas las medidas estándares existentes para un producto en particular y cargarlas
		 * como posibles requerimientos de compra.
		 */
		
		int codigoClase = requerimientoSeleccionado.getProducto().getElemento().getClase().getCodigo();
		int codigoElemento = requerimientoSeleccionado.getProducto().getElemento().getCodigo();
		int codigoMaterial = requerimientoSeleccionado.getProducto().getMaterial().getCodigo();
		List<ProductoDTO> listaProductosMedidasEstandar = new LinkedList<ProductoDTO>();
		IngenieriaServiceImpl adminIngenieria = new IngenieriaServiceImpl();
		
		listaProductosMedidasEstandar = adminIngenieria.buscarProductos(codigoClase, codigoElemento, codigoMaterial);
		
		List<RequerimientoCompraDTO> listaRequerimientoCompra = new LinkedList<RequerimientoCompraDTO>();
		requerimientoSeleccionado.getRequerimientoCompras().clear();
		
		String medidaFijaBuscada = requerimientoSeleccionado.getProducto().getMedidaFija().getMedida();
		
		ProductoDTO productoRequerido = new ProductoDTO();
		
		//Busco la medida fija que corresponde.
		for (int i = 0; i < listaProductosMedidasEstandar.size(); i++) {
			if (listaProductosMedidasEstandar.get(i).getMedidaFija().getMedida().equals(medidaFijaBuscada))
				productoRequerido = listaProductosMedidasEstandar.get(i);					
		}
		
		//Para cada medida variable estandar que existe de ese producto...
		for (int i = 0; i < productoRequerido.getMedidasEstandar().size(); i++) {
			
			//Creamos el requerimiento compra para añadirlo a la lista de requerimientos de compra.
			RequerimientoCompraDTO requerimientoCompra = new RequerimientoCompraDTO();
			
			requerimientoCompra.setMedidaVariable1(Double.parseDouble(String.valueOf(productoRequerido.getMedidasEstandar().get(i).getMedidaVariable1())));
			requerimientoCompra.setMedidaVariable2(Double.parseDouble(String.valueOf(productoRequerido.getMedidasEstandar().get(i).getMedidaVariable2())));
			requerimientoCompra.setRequerimientoMaterial(requerimientoSeleccionado);
			listaRequerimientoCompra.add(requerimientoCompra);
		}
		
		requerimientoSeleccionado.setRequerimientoCompras(listaRequerimientoCompra);
		
		
		/*
		 * Sección que se encarga de comprobar la existencia de reservas realizadas en alguna sesión anterior y cargarlas como reservas de producto.
		 */
		
		int idRequerimientoMaterial = requerimientoSeleccionado.getIdRequerimientoMaterial();
		List<ReservaProductoDTO> listaReservaProductoRealizada = new LinkedList<ReservaProductoDTO>();
		
		listaReservaProductoRealizada = buscarReservaProducto(idRequerimientoMaterial);
		
		List<ReservaProductoDTO> listaReservaProductoExistente = requerimientoSeleccionado.getReservaProductos();
		
		int i = 0;
		
		//Mientras que haya reservas de productos de la base de datos...
		while (listaReservaProductoRealizada.size() > i) {
			
			ReservaProductoDTO reservaProducto = listaReservaProductoRealizada.get(i);
			
			int j = 0;
		
			//Mientras que queden reservas de productos ya cargadas para comparar...
			while (listaReservaProductoExistente.size() > j) {
				
				ReservaProductoDTO reservaProductoExistente = listaReservaProductoExistente.get(j);
				
				//Si la reserva de productos ya existía de antes, entonces eliminamos de la lista la reserva existente.
				//De hecho, siempre va a existir esta reserva, pues son todos los productos existentes en almacén, con sus diversas medidas.
				if(((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(reservaProducto.getInventario().getMedida1()))) &&
						(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(reservaProducto.getInventario().getMedida2()))))
						||
						((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(reservaProducto.getInventario().getMedida2()))) &&
						(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(reservaProducto.getInventario().getMedida1()))))){
					
					requerimientoSeleccionado.getReservaProductos().remove(j);							
				}
				
				j++;
			}
			
			reservaProducto.setCantidadReservadaPendienteEntrega(0.0);
			
			//Agregamos la reserva realizada en otra sesión.
			requerimientoSeleccionado.getReservaProductos().add(reservaProducto);
			
			i++;
		}
		
		
		/*
		 * Sección que se encarga de comprobar la existencia de compras realizadas en alguna sesión anterior y cargarlas como requerimientos de compra.
		 * Si el requerimiento de compra no está activo, se carga como reserva de producto pendiente de entrega.
		 */
		
		List<RequerimientoCompraDTO> listaRequerimientoCompraRealizado = new LinkedList<RequerimientoCompraDTO>();
		
		listaRequerimientoCompraRealizado = buscarRequerimientoCompra(idRequerimientoMaterial);
		
		i = 0;
		
		//Mientras que haya requerimientos de compra de la base de datos...
		while (listaRequerimientoCompraRealizado.size() > i) {
			
			RequerimientoCompraDTO requerimientoCompra = listaRequerimientoCompraRealizado.get(i);
			
			//Si existe un requerimiento de compra que no está activo, se colocará como reserva en camino.
			if(!requerimientoCompra.isActivo()) {
				int j = 0;
				
				//Mientras que queden reservas de productos ya cargadas para comparar...
				while (requerimientoSeleccionado.getReservaProductos().size() > j) {
					
					ReservaProductoDTO reservaProductoExistente = requerimientoSeleccionado.getReservaProductos().get(j);
											
					//Si existe una reserva de productos con las mismas medidas, se deben actualizar las cantidades pendientes de entrega de esa reserva,
					//Siempre existirá una reserva de productos con estas medidas, ya que se hallarán en almacén sí o sí.
					if(((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(requerimientoCompra.getMedidaVariable1()))) &&
							(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(requerimientoCompra.getMedidaVariable2()))))
							||
							((String.valueOf(reservaProductoExistente.getInventario().getMedida1()).equals(String.valueOf(requerimientoCompra.getMedidaVariable2()))) &&
							(String.valueOf(reservaProductoExistente.getInventario().getMedida2()).equals(String.valueOf(requerimientoCompra.getMedidaVariable1()))))) {
	
						requerimientoSeleccionado.getReservaProductos().get(j).setCantidadReservadaPendienteEntrega(
								requerimientoSeleccionado.getReservaProductos().get(j).getCantidadReservadaPendienteEntrega() + requerimientoCompra.getCantidadRequerida());
					}
					
					j++;
				}
			}
								
			i++;
		}
		
		//Hacemos limpieza de las reservas que no tienen ni disponible ni reservado pendiente de entrega ni reservado.
		int reservaNro = 0;
		
		listaReservaProductoExistente = requerimientoSeleccionado.getReservaProductos();
		
		while (listaReservaProductoExistente.size() > reservaNro) {
			
			ReservaProductoDTO reservaProductoExistente = listaReservaProductoExistente.get(reservaNro);

			//Si no tiene disponibilidad, ni reserva en camino, ni reserva realizada, se elimina el renglón.
			if((reservaProductoExistente.getCantidadReservada().compareTo(0.0) == 0) &&
					(reservaProductoExistente.getCantidadReservadaPendienteEntrega().compareTo(0.0) == 0) &&
					(reservaProductoExistente.getInventario().getCantidadDisponible().compareTo(0.0) == 0)) {
				listaReservaProductoExistente.remove(reservaNro);							
			}
			else
				reservaNro++;
		}
		
		requerimientoSeleccionado.setReservaProductos(listaReservaProductoExistente);
		
		//Hacemos limpieza de los requerimientos de compra que no están en activas.
		int compraNro = 0;
		
		listaRequerimientoCompraRealizado = buscarRequerimientoCompra(idRequerimientoMaterial);
		List<RequerimientoCompraDTO> listaRequerimientoCompraExistente = new LinkedList<RequerimientoCompraDTO>();
		
		//Mientras que haya requerimientos de compra de la base de datos...
		while (listaRequerimientoCompraRealizado.size() > compraNro) {
			
			RequerimientoCompraDTO requerimientoCompra = listaRequerimientoCompraRealizado.get(compraNro);
			
			//Si existe un requerimiento de compra que no está activo, se lo elimina de la lista.
			if(requerimientoCompra.isActivo()) {
				listaRequerimientoCompraExistente.add(requerimientoCompra);
			}
								
			compraNro++;
		}
		
		/*
		 * Cálculo del total reservado.
		 */
		
		List<ReservaProductoDTO> listaReservaProductoTotales = requerimientoSeleccionado.getReservaProductos();
		double totalReservado = 0;
		
		for (i = 0; i < listaReservaProductoTotales.size(); i++) {
			
			//Calculamos el total reservado hasta el momento, que involucra lo reservado más lo reservado en tránsito.
			
			if (((listaReservaProductoTotales.get(i).getInventario().getMedida1().equals("0.0") || listaReservaProductoTotales.get(i).getInventario().getMedida1().equals(null))) && 
					((listaReservaProductoTotales.get(i).getInventario().getMedida2().equals("0.0") || listaReservaProductoTotales.get(i).getInventario().getMedida2().equals(null))))
				totalReservado = totalReservado + (listaReservaProductoTotales.get(i).getCantidadReservada() + listaReservaProductoTotales.get(i).getCantidadReservadaPendienteEntrega());
			else if((listaReservaProductoTotales.get(i).getInventario().getMedida2().equals("0.0") || listaReservaProductoTotales.get(i).getInventario().getMedida2().equals(null)))
				totalReservado = totalReservado + (listaReservaProductoTotales.get(i).getCantidadReservada() + listaReservaProductoTotales.get(i).getCantidadReservadaPendienteEntrega()) * Double.parseDouble(listaReservaProductoTotales.get(i).getInventario().getMedida1());
			else
				totalReservado = totalReservado + (listaReservaProductoTotales.get(i).getCantidadReservada() + listaReservaProductoTotales.get(i).getCantidadReservadaPendienteEntrega()) * Double.parseDouble(listaReservaProductoTotales.get(i).getInventario().getMedida1()) * Double.parseDouble(listaReservaProductoTotales.get(i).getInventario().getMedida2());
		}
		
		
		/*
		 * Cálculo del total solicitado.
		 */
		
		List<RequerimientoCompraDTO> listaRequerimientoCompraTotales = listaRequerimientoCompraExistente;
		double totalSolicitado = 0;
		
		for (i = 0; i < listaRequerimientoCompraTotales.size(); i++) {
			
			//Calculamos el total solicitado hasta el momento.
			if((listaRequerimientoCompraTotales.get(i).getMedidaVariable1().compareTo(0.0) == 0) && (listaRequerimientoCompraTotales.get(i).getMedidaVariable2().compareTo(0.0) == 0))
				totalSolicitado = totalSolicitado + listaRequerimientoCompraTotales.get(i).getCantidadRequerida();
			else if(listaRequerimientoCompraTotales.get(i).getMedidaVariable2().compareTo(0.0) == 0)
				totalSolicitado = totalSolicitado + listaRequerimientoCompraTotales.get(i).getCantidadRequerida() * listaRequerimientoCompraTotales.get(i).getMedidaVariable1();
			else
				totalSolicitado = totalSolicitado + listaRequerimientoCompraTotales.get(i).getCantidadRequerida() * listaRequerimientoCompraTotales.get(i).getMedidaVariable1() * listaRequerimientoCompraTotales.get(i).getMedidaVariable2();
		}
		
		
		/*
		 * Cálculo del requerimiento bruto.
		 */
		
		requerimientoSeleccionado.setRequerimientoBruto(0.0);
		
		for(int j = 0; j < requerimientoSeleccionado.getListaMaterialesRequeridos().size(); j++) {
		
			if((requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable1().compareTo(0.0) == 0) && (requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable2().compareTo(0.0) == 0))
				requerimientoSeleccionado.setRequerimientoBruto(requerimientoSeleccionado.getRequerimientoBruto() + requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getCantidad());
			else if(requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable2().compareTo(0.0) == 0)
				requerimientoSeleccionado.setRequerimientoBruto(requerimientoSeleccionado.getRequerimientoBruto() + requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable1() * requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getCantidad());
			else
				requerimientoSeleccionado.setRequerimientoBruto(requerimientoSeleccionado.getRequerimientoBruto() + requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable1() * requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getMedidaVariable2() * requerimientoSeleccionado.getListaMaterialesRequeridos().get(j).getCantidad());
		}
				
		requerimientoSeleccionado.setCantidadReservada(totalReservado);
		requerimientoSeleccionado.setCantidadSolicitada(totalSolicitado);
		requerimientoSeleccionado.setTotalRSP(totalReservado + totalSolicitado + requerimientoSeleccionado.getCantidadProvista());
		
		return requerimientoSeleccionado;
	}
	
	
	/**
	 * Método que se encarga de buscar las reservas de productos realizadas en otra sesión.
	 */
	public List<ReservaProductoDTO> buscarReservaProducto(int idRequerimientoMaterial) {

		List<ReservaProducto> listaReservaProducto = new LinkedList<ReservaProducto>();
		List<ReservaProductoDTO> listaReservaProductoDTO = new LinkedList<ReservaProductoDTO>();
		Produccion adminProduccion = new Produccion();
		
		listaReservaProducto = adminProduccion.buscarReservaProducto(idRequerimientoMaterial);
		
		for(ReservaProducto reservaProducto: listaReservaProducto) {
			
			ReservaProductoDTO reservaProductoDTO = new ReservaProductoDTO();
			
			reservaProductoDTO.setCantidadReservada(reservaProducto.getCantidadReservada());
			reservaProductoDTO.setIdReserva(reservaProducto.getIdReserva());
			reservaProductoDTO.setCantidadReservadaPendienteEntrega(Double.valueOf(0));
			
			InventarioDTO inventarioDTO = new InventarioDTO();
			
			inventarioDTO.setIdInventario(reservaProducto.getInventario().getIdInventario());
			inventarioDTO.setCantDisponiblePendienteEntrega(reservaProducto.getInventario().getCantDisponiblePendienteEntrega());
			inventarioDTO.setCantidadDisponible(reservaProducto.getInventario().getCantidadDisponible());
			inventarioDTO.setMedida1(reservaProducto.getInventario().getMedida1());
			inventarioDTO.setMedida2(reservaProducto.getInventario().getMedida2());
			
			reservaProductoDTO.setInventario(inventarioDTO);
			
			RequerimientoMaterialDTO requerimientoMaterialDTO = new RequerimientoMaterialDTO();

			requerimientoMaterialDTO.setIdRequerimientoMaterial(idRequerimientoMaterial);
			
			reservaProductoDTO.setRequerimientoMateriales(requerimientoMaterialDTO);
			
			listaReservaProductoDTO.add(reservaProductoDTO);
		}
		
		return listaReservaProductoDTO;
	}
	
	/**
	 * Método que se encarga de cargar los requerimientos de compra realizados en otra sesión.
	 */
	public List<RequerimientoCompraDTO> buscarRequerimientoCompra(int idRequerimientoMaterial) {
		
		List<RequerimientoCompra> listaRequerimientoCompra = new LinkedList<RequerimientoCompra>();
		List<RequerimientoCompraDTO> listaRequerimientoComptraDTO = new LinkedList<RequerimientoCompraDTO>();
		Produccion adminProduccion = new Produccion();
		
		listaRequerimientoCompra = adminProduccion.buscarRequerimientoCompra(idRequerimientoMaterial);
		
		for(RequerimientoCompra requerimientoCompra: listaRequerimientoCompra) {
			
			RequerimientoCompraDTO requerimientoCompraDTO = new RequerimientoCompraDTO();
			
			requerimientoCompraDTO.setActivo(requerimientoCompra.isActivo());
			requerimientoCompraDTO.setCantidadRequerida(requerimientoCompra.getCantidadRequerida());
			requerimientoCompraDTO.setFechaRequerimientoCompra(requerimientoCompra.getFechaRequerimientoCompra());
			requerimientoCompraDTO.setIdRequerimientoCompra(requerimientoCompra.getIdRequerimientoCompra());
			requerimientoCompraDTO.setMedidaVariable1(requerimientoCompra.getMedidaVariable1());
			
			if(requerimientoCompra.getMedidaVariable2().equals(null) || requerimientoCompra.getMedidaVariable2().equals(0.0))
				requerimientoCompraDTO.setMedidaVariable2(0.0);
			else
				requerimientoCompraDTO.setMedidaVariable2(requerimientoCompra.getMedidaVariable2());
			
			RequerimientoMaterialDTO requerimientoMaterialDTO = new RequerimientoMaterialDTO();

			requerimientoMaterialDTO.setIdRequerimientoMaterial(idRequerimientoMaterial);
			
			requerimientoCompraDTO.setRequerimientoMaterial(requerimientoMaterialDTO);
			
			listaRequerimientoComptraDTO.add(requerimientoCompraDTO);
		}
		
		return listaRequerimientoComptraDTO;
	}

	@Override
	public RequerimientoMaterialDTO registrarReservasYCompras(RequerimientoMaterialDTO requerimientoMaterialDTO) {

		//RequerimientoCompraDTO y ReservaProductoDTO
		
		//Entidades a guardar en tabla requerimiento compras: requerimientoMaterialDTO.getRequerimientoCompras();
		//Entidades a guardar en tabla reserva productos: requerimientoMaterialDTO.getReservaProductos();

		//Para aquellas ReservaProductoDTO que tengan las cantidades iguales a 0, habrá que comprobar si ya existen en base de datos (si su id es
		//distinto de 0). Si existen, habrá que eliminarlas.
		//Si id = 0 y cantidad > 0, entonces guardamos.
		//Si id != 0 y cantidad > 0, entonces guardamos (actualizamos un registro existente).
		//Si id != 0 y cantidad = 0, entonces eliminamos la entidad.
		
		//Además, habrá que actualizar los registros de InventarioDTO. Los mismos vienen en 
		//requerimientoMaterialDTO.getReservaProductos().get(i).getInventario();
		
		//Los RequerimientoCompraDTO vendrán todos con su id = 0.
		//Habrá que guardar todos, ya que los que lleguen llegarán con cantidad mayor a 0.
		
		Produccion adminProduccion = new Produccion();
		D_Inventario inventarioAdmin = new D_Inventario();		
		
		////////////// reserva de productos
		
		List<ReservaProductoDTO> listaReservaProductosDTO = requerimientoMaterialDTO.getReservaProductos();
		
		//FALTA ACTUALIZAR LA CANTIDAD DISPONIBLE EN INVENTARIO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
		
		// para cada reserva
		for (ReservaProductoDTO reservaProductoDTO: listaReservaProductosDTO) {
			
			// si se canceló la reserva
			if (reservaProductoDTO.getIdReserva() != 0 && reservaProductoDTO.getCantidadReservada() == 0) {
				
				adminProduccion.eliminarReserva(reservaProductoDTO.getIdReserva());
			}
			
			// si se actualizó la reserva
			else if (reservaProductoDTO.getIdReserva() != 0 && reservaProductoDTO.getCantidadReservada() > 0) {
				
				adminProduccion.actualizarReserva(reservaProductoDTO);				
			}
			
			// si se genera una nueva reserva
			else if (reservaProductoDTO.getIdReserva() == 0 && reservaProductoDTO.getCantidadReservada() > 0) {
				
				ReservaProducto reservaProducto = new ReservaProducto();
				
				reservaProducto.setCantidadReservada(reservaProductoDTO.getCantidadReservada());				
								
				Inventario inventario = new Inventario();				
				inventario = inventarioAdmin.buscarInventario(reservaProductoDTO.getInventario().getIdInventario());
				
				reservaProducto.setInventario(inventario);
				
				// se busca el requerimiento de material que se supone ya guardado
				
				RequerimientoMateriales requerimientoMateriales = new RequerimientoMateriales();
				requerimientoMateriales = adminProduccion.buscarRequerimientoMateriales(reservaProductoDTO.getRequerimientoMateriales().getIdRequerimientoMaterial());
				
				reservaProducto.setRequerimientoMateriales(requerimientoMateriales);			
				
				// se registra la nueva reserva
				adminProduccion.registrarReservaProducto(reservaProducto);
			}
			
			//Se actualizan las cantidades disponibles en inventario.			
			Inventario inventario = new Inventario();				
			inventario = inventarioAdmin.buscarInventario(reservaProductoDTO.getInventario().getIdInventario());
			
			inventario.setCantidadDisponible(reservaProductoDTO.getInventario().getCantidadDisponible());
			
			inventarioAdmin.registrar(inventario);
		}
		
		
		////////////// requerimientos de compra
		
		List<RequerimientoCompraDTO> listaRequerimientosCompraDTO = requerimientoMaterialDTO.getRequerimientoCompras();
		
		// para cada requerimiento de compra
		
		for (RequerimientoCompraDTO requerimientoCompraDTO: listaRequerimientosCompraDTO) {
			
			if(requerimientoCompraDTO.getCantidadRequerida() != 0) {
				RequerimientoCompra requerimientoCompra = new RequerimientoCompra();
				
				requerimientoCompra.setActivo(true);
				requerimientoCompra.setCantidadRequerida(requerimientoCompraDTO.getCantidadRequerida());
				requerimientoCompra.setFechaRequerimientoCompra(requerimientoCompraDTO.getFechaRequerimientoCompra());
				requerimientoCompra.setMedidaVariable1(requerimientoCompraDTO.getMedidaVariable1());
				requerimientoCompra.setMedidaVariable2(requerimientoCompraDTO.getMedidaVariable2());
								
				// se busca el requerimiento de material que se supone ya guardado
				
				RequerimientoMateriales requerimientoMateriales = new RequerimientoMateriales();
				requerimientoMateriales = adminProduccion.buscarRequerimientoMateriales(requerimientoCompraDTO.getRequerimientoMaterial().getIdRequerimientoMaterial());
				
				requerimientoCompra.setRequerimientoMateriales(requerimientoMateriales);			
				
				// se registra el nuevo requerimiento de compra
				
				adminProduccion.registrarRequerimientoCompra(requerimientoCompra);
			}
		}
		
		return requerimientoMaterialDTO;
	}
}
